home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 38 / Amiga Format CD38 (1999-03-15)(Future Publishing)(GB)(Track 1 of 3)[!][issue 1999-04].iso / -seriously_amiga- / programming / other / cyberxxxsrc / cyberqt / txt / cyberqtvideo.mod < prev   
Text File  |  1999-02-08  |  81KB  |  2,214 lines
  1. MODULE  CyberQTVideo;
  2.  
  3. (* $IFNOT DEBUG *)
  4.   (* $StackChk- $OvflChk- $RangeChk- $CaseChk- $ReturnChk- $NilChk- $TypeChk- $OddChk- $ClearVars- *)
  5. (* $END *)
  6.  
  7. (* /// ------------------------------- "IMPORT" -------------------------------- *)
  8. IMPORT  b:=BestModeID,
  9.         cgfx:=CyberGraphics,
  10.         cu:=CyberQTUtils,
  11.         d:=Dos,
  12.         e:=Exec,
  13.         es:=ExecSupport,
  14.         fp:=FixedPoint,
  15.         g:=CyberQTGlobals,
  16.         gfx:=Graphics,
  17.         i:=Intuition,
  18.         iff:=IFFParse,
  19.         io:=AsyncIOSupport2,
  20.         i2m:=Intel2Mot,
  21.         lv:=LibraryVer,
  22.         m:=MathTrans,
  23.         mu:=MathUtils,
  24.         o:=CyberQTOpts,
  25.         ol:=OberonLib,
  26.         s:=CyberQTSync,
  27.         sl:=StringLib,
  28.         u:=Utility,
  29.         y:=SYSTEM,
  30.         ys:=YUVStuff;
  31. (* \\\ ------------------------------------------------------------------------- *)
  32.  
  33. (* /// -------------------------------- "CONST" -------------------------------- *)
  34. CONST   idmsvc=y.VAL(LONGINT,"msvc");
  35.         idMSVC=y.VAL(LONGINT,"MSVC");
  36.         idcram=y.VAL(LONGINT,"cram");
  37.         idCRAM=y.VAL(LONGINT,"CRAM");
  38.         idrle =y.VAL(LONGINT,"rle ");
  39.         idsmc =y.VAL(LONGINT,"smc ");
  40.         idraw =y.VAL(LONGINT,"raw ");
  41.         idrpza=y.VAL(LONGINT,"rpza");
  42.         idazpr=y.VAL(LONGINT,"azpr");
  43.         idjpeg=y.VAL(LONGINT,"jpeg");
  44.         idRT21=y.VAL(LONGINT,"RT21");
  45.         idrt21=y.VAL(LONGINT,"rt21");
  46.         idIV31=y.VAL(LONGINT,"IV31");
  47.         idiv31=y.VAL(LONGINT,"iv31");
  48.         idIV32=y.VAL(LONGINT,"IV32");
  49.         idiv32=y.VAL(LONGINT,"iv32");
  50.         idIV41=y.VAL(LONGINT,"IV41");
  51.         idiv41=y.VAL(LONGINT,"iv41");
  52.         idIV50=y.VAL(LONGINT,"IV50");
  53.         idiv50=y.VAL(LONGINT,"iv50");
  54.         idCVID=y.VAL(LONGINT,"CVID");
  55.         idcvid=y.VAL(LONGINT,"cvid");
  56.         idYUV2=y.VAL(LONGINT,"YUV2");
  57.         idyuv2=y.VAL(LONGINT,"yuv2");
  58.         id2VUY=y.VAL(LONGINT,"2VUY");
  59.         id2vuy=y.VAL(LONGINT,"2vuy");
  60.         idYUV9=y.VAL(LONGINT,"YUV9");
  61.         idYVU9=y.VAL(LONGINT,"YVU9");
  62.         id9VUY=y.VAL(LONGINT,"9VUY");
  63.         id9UVY=y.VAL(LONGINT,"9UVY");
  64.         idXMPG=y.VAL(LONGINT,"XMPG");
  65.         idxmpg=y.VAL(LONGINT,"xmpg");
  66.         idCYUV=y.VAL(LONGINT,"CYUV");
  67.         idcyuv=y.VAL(LONGINT,"cyuv");
  68.         idkpcd=y.VAL(LONGINT,"kpcd");
  69.         idKPCD=y.VAL(LONGINT,"KPCD");
  70.         idmjpa=y.VAL(LONGINT,"mjpa");
  71.         idmjpb=y.VAL(LONGINT,"mjpb");
  72.  
  73.         codecSupported * =1;
  74.         codecUnknown * =0;
  75.         codecUnsupported * =-1;
  76.  
  77.         tmpRasSize=4096;
  78. (* \\\ ------------------------------------------------------------------------- *)
  79.  
  80. (* /// -------------------------------- "TYPE" --------------------------------- *)
  81. TYPE    DecoderProc=PROCEDURE(from{8}: e.APTR;
  82.                               to{9}: e.APTR;
  83.                               width{0}: LONGINT;
  84.                               height{1}: LONGINT;
  85.                               encSize{2}: LONGINT;
  86.                               spec{10}: e.APTR);
  87.  
  88.         FastC2PProc=PROCEDURE(chunky{8}: e.APTR;
  89.                               bitmap{9}: gfx.BitMapPtr;
  90.                               realWidth{1}: LONGINT);
  91.  
  92.         DisplayProc=PROCEDURE();
  93.  
  94.         CodecHeader=STRUCT
  95.             decoder: DecoderProc;
  96.             special: e.APTR;
  97.             compression: LONGINT;
  98.             width: LONGINT;
  99.             height: LONGINT;
  100.             depth: LONGINT;
  101.             description: e.STRING;
  102.         END;
  103.  
  104.         CodecArray=UNTRACED POINTER TO ARRAY MAX(INTEGER) OF CodecHeader;
  105.  
  106.         ColorReg=STRUCT
  107.             red: LONGINT;
  108.             green: LONGINT;
  109.             blue: LONGINT;
  110.         END;
  111.         ColorRegArrayPtr=UNTRACED POINTER TO ColorRegArray;
  112.         ColorRegArray=ARRAY 256 OF ColorReg;
  113.  
  114.         ColorMapPtr=UNTRACED POINTER TO ColorMap;
  115.         ColorMap=STRUCT
  116.             count: INTEGER;
  117.             first: INTEGER;
  118.             colors: ColorRegArray;
  119.             last: LONGINT;
  120.         END;
  121.         ColorMapArrayPtr=UNTRACED POINTER TO ColorMapArray;
  122.         ColorMapArray=ARRAY SIZE(ColorMap) DIV SIZE(LONGINT) OF LONGINT;
  123.  
  124.         CMapArrPtr=UNTRACED POINTER TO CMapArr;
  125.         CMapArr=ARRAY 256 OF STRUCT
  126.             alpha: CHAR;
  127.             red: CHAR;
  128.             green: CHAR;
  129.             blue: CHAR;
  130.         END;
  131. (* \\\ ------------------------------------------------------------------------- *)
  132.  
  133. (* /// --------------------------------- "VAR" --------------------------------- *)
  134. VAR     videoFile: io.ASFile;
  135.         screen: i.ScreenPtr;
  136.         window: i.WindowPtr;
  137.         mouse: i.ObjectPtr;
  138.         mouseBitMap: gfx.BitMapPtr;
  139.         colorReduction: BOOLEAN;
  140.         ham8: BOOLEAN;
  141.         animWidth: INTEGER;
  142.         animHeight: INTEGER;
  143.         animDepth: LONGINT;
  144.         dispModulo: INTEGER;
  145.         calcWidth: LONGINT;
  146.         calcHeight: LONGINT;
  147.         colorMap: ColorMapPtr;
  148.         videoBufferSize: LONGINT;
  149.         videoData: e.LSTRPTR;
  150.         videoDataDec: e.LSTRPTR;
  151.         ham8Buffer: e.LSTRPTR;
  152.         codecs: CodecArray;
  153.         codecCnt: LONGINT;
  154.         currentCodec: LONGINT;
  155.         decoderProc: DecoderProc;
  156.         displayProc: DisplayProc;
  157.         fastc2pProc: FastC2PProc;
  158.         decoderSpec: e.APTR;
  159.         idcmpSig - : LONGINT;
  160.         leftOff: INTEGER;
  161.         topOff: INTEGER;
  162.         rp: gfx.RastPortPtr;
  163.         tmpBM: gfx.BitMapPtr;
  164.         tmpRas: gfx.TmpRasPtr;
  165.         tmpRasMem: UNTRACED POINTER TO ARRAY tmpRasSize OF CHAR;
  166.         grayScale: BOOLEAN;
  167.         pubScreen: BOOLEAN;
  168.         colorType: LONGINT;
  169.         frameSize: LONGINT;
  170.         cmap: CMapArrPtr;
  171.         doubleScanned - : BOOLEAN;
  172. (* \\\ ------------------------------------------------------------------------- *)
  173.  
  174. (* /// ----------------------- "PROCEDURE HandleIDCMP()" ----------------------- *)
  175. PROCEDURE HandleIDCMP * (): LONGINT;
  176.  
  177. VAR     msg: i.IntuiMessagePtr;
  178.         ret: LONGINT;
  179.  
  180. BEGIN
  181.   ret:=g.noError;
  182.   msg:=e.GetMsg(window.userPort);
  183.   IF msg#NIL THEN
  184.     IF i.vanillaKey IN msg.class THEN
  185.       CASE msg.code OF
  186.       | 3: ret:=d.break; (* CTRL-C *)
  187.       | 4: ret:=g.skipAnim; (* CTRL-D *)
  188.       | 27: ret:=g.skipAnim; (* ESC *)
  189. (*
  190.       | ORD("P"),ORD("p"): ret:=g.pauseAnim;
  191. *)
  192.       ELSE
  193.       END;
  194.     ELSIF i.rawKey IN msg.class THEN
  195.       CASE msg.code OF
  196.       | 69: ret:=g.skipAnim     (* ESC *)
  197.       | 80: s.SetSpeedFactor( 0.0);      (* F1, maximal *)
  198.       | 81: s.SetSpeedFactor( 0.1);      (* F2, 1000%   *)
  199.       | 82: s.SetSpeedFactor( 0.2);      (* F3,  500%   *)
  200.       | 83: s.SetSpeedFactor( 0.333333); (* F4,  300%   *)
  201.       | 84: s.SetSpeedFactor( 0.5);      (* F5,  200%   *)
  202.       | 85: s.SetSpeedFactor( 1.0);      (* F6,  100%   *)
  203.       | 86: s.SetSpeedFactor( 1.333333); (* F7,   75%   *)
  204.       | 87: s.SetSpeedFactor( 2.0);      (* F8,   50%   *)
  205.       | 88: s.SetSpeedFactor( 5.0);      (* F9,   20%   *)
  206.       | 89: s.SetSpeedFactor(10.0);      (* F10,  10%   *)
  207.       ELSE
  208.       END;
  209.     ELSE
  210.       ret:=g.skipAnim;
  211.     END;
  212.     e.ReplyMsg(msg);
  213.   END;
  214.   RETURN ret;
  215. END HandleIDCMP;
  216. (* \\\ ------------------------------------------------------------------------- *)
  217.  
  218. (* /// ------------------- "PROCEDURE ReadExternalPalette()" ------------------- *)
  219. PROCEDURE ReadExternalPalette();
  220.  
  221. CONST   idILBM=y.VAL(LONGINT,"ILBM");
  222.         idCMAP=y.VAL(LONGINT,"CMAP");
  223.  
  224. VAR     handle: iff.IFFHandlePtr;
  225.         fh: d.FileHandlePtr;
  226.         chunk: iff.ContextNodePtr;
  227.         buffer: ARRAY 768 OF CHAR;
  228.         error: LONGINT;
  229.         cnt: LONGINT;
  230.         numColors: LONGINT;
  231.  
  232. BEGIN
  233.   IF iff.base=NIL THEN RETURN; END;
  234.   handle:=iff.AllocIFF();
  235.   IF handle#NIL THEN
  236.     fh:=d.Open(o.cmap,d.oldFile);
  237.     IF fh#NIL THEN
  238.       handle.stream:=y.VAL(LONGINT,fh);
  239.       iff.InitIFFasDOS(handle);
  240.       IF iff.OpenIFF(handle,iff.read)=0 THEN
  241.         IF iff.StopChunk(handle,idILBM,idCMAP)=0 THEN
  242.           IF iff.ParseIFF(handle,iff.parseScan)=0 THEN
  243.             chunk:=iff.CurrentChunk(handle);
  244.             numColors:=chunk.size DIV 3;
  245.             error:=iff.ReadChunkBytes(handle,buffer,mu.min(chunk.size,SIZE(buffer)));
  246.             FOR cnt:=0 TO numColors-1 DO
  247.               colorMap.colors[cnt].red:=i2m.ByteTo32(buffer[cnt*3+0]);
  248.               colorMap.colors[cnt].green:=i2m.ByteTo32(buffer[cnt*3+1]);
  249.               colorMap.colors[cnt].blue:=i2m.ByteTo32(buffer[cnt*3+2]);
  250.               (* cmap[cnt] nicht setzen, sonst gibts massiv Falschfarben *)
  251.             END;
  252.             FOR cnt:=numColors TO 255 DO
  253.               colorMap.colors[cnt].red:=0;
  254.               colorMap.colors[cnt].green:=0;
  255.               colorMap.colors[cnt].blue:=0;
  256.             END;
  257.             colorMap.count:=i.LongToUInt(numColors);
  258.             colorMap.first:=0;
  259.             colorMap.last:=numColors-1;
  260.           END;
  261.         END;
  262.         iff.CloseIFF(handle);
  263.       END;
  264.       d.OldClose(fh);
  265.     END;
  266.     iff.FreeIFF(handle);
  267.   END;
  268. END ReadExternalPalette;
  269. (* \\\ ------------------------------------------------------------------------- *)
  270.  
  271. (* /// --------------------- "PROCEDURE Init332ColorMap()" --------------------- *)
  272. PROCEDURE Init332ColorMap();
  273.  
  274. VAR     cnt: LONGINT;
  275.         g: LONGINT;
  276.  
  277. BEGIN
  278.   IF colorMap=NIL THEN NEW(colorMap); END;
  279.   FOR cnt:=0 TO 255 DO
  280.     IF grayScale THEN
  281.       g:=i2m.ByteTo32(CHR(cnt));
  282.       colorMap.colors[cnt].red:=g;
  283.       colorMap.colors[cnt].green:=g;
  284.       colorMap.colors[cnt].blue:=g;
  285.       cmap[cnt].red:=CHR(cnt);
  286.       cmap[cnt].green:=CHR(cnt);
  287.       cmap[cnt].blue:=CHR(cnt);
  288.     ELSE
  289.       colorMap.colors[cnt].red:=y.LSH(y.VAL(LONGINT,y.LSH(y.VAL(LONGSET,cnt)*LONGSET{5..7},-5))*9362,16);
  290.       colorMap.colors[cnt].green:=y.LSH(y.VAL(LONGINT,y.LSH(y.VAL(LONGSET,cnt)*LONGSET{2..4},-2))*9362,16);
  291.       colorMap.colors[cnt].blue:=y.LSH(y.VAL(LONGINT,y.VAL(LONGSET,cnt)*LONGSET{0..1})*21845,16);
  292.       cmap[cnt].red:=CHR(y.LSH(y.VAL(LONGINT,y.LSH(y.VAL(LONGSET,cnt)*LONGSET{5..7},-5))*9362,-8));
  293.       cmap[cnt].green:=CHR(y.LSH(y.VAL(LONGINT,y.LSH(y.VAL(LONGSET,cnt)*LONGSET{2..4},-2))*9362,-8));
  294.       cmap[cnt].blue:=CHR(y.LSH(y.VAL(LONGINT,y.VAL(LONGSET,cnt)*LONGSET{0..1})*21845,-8));
  295.     END;
  296.   END;
  297.   colorMap.count:=256;
  298.   colorMap.first:=0;
  299.   colorMap.last:=255;
  300.   IF o.cmap#"" THEN ReadExternalPalette(); END;
  301. END Init332ColorMap;
  302. (* \\\ ------------------------------------------------------------------------- *)
  303.  
  304. (* /// -------------------- "PROCEDURE InitHAM8ColorMap()" --------------------- *)
  305. PROCEDURE InitHAM8ColorMap();
  306.  
  307. VAR     cnt: INTEGER;
  308.         rr: INTEGER;
  309.         gg: INTEGER;
  310.         bb: INTEGER;
  311.  
  312. BEGIN
  313.   IF colorMap=NIL THEN NEW(colorMap); END;
  314.   rr:=0;
  315.   gg:=0;
  316.   bb:=0;
  317.   FOR cnt:=0 TO 63 DO
  318.     colorMap.colors[cnt].red:=y.LSH(rr,30)+y.LSH(rr,24);
  319.     colorMap.colors[cnt].green:=y.LSH(gg,30)+y.LSH(gg,24);
  320.     colorMap.colors[cnt].blue:=y.LSH(bb,30)+y.LSH(bb,24);
  321.     INC(bb);
  322.     IF bb>3 THEN
  323.       bb:=0;
  324.       INC(gg);
  325.       IF gg>3 THEN
  326.         gg:=0;
  327.         INC(rr);
  328.       END;
  329.     END;
  330.   END;
  331.   colorMap.count:=64;
  332.   colorMap.first:=0;
  333.   colorMap.last:=63;
  334. END InitHAM8ColorMap;
  335. (* \\\ ------------------------------------------------------------------------- *)
  336.  
  337. (* /// --------------------- "PROCEDURE InitDefColorMap()" --------------------- *)
  338. PROCEDURE InitDefColorMap(depth: LONGINT);
  339.  
  340.  
  341. CONST   qt4map="\xFF\xFB\xFF"
  342.                "\xEF\xD9\xBB"
  343.                "\xE8\xC9\xB1"
  344.                "\x93\x65\x5E"
  345.                "\xFC\xDE\xE8"
  346.                "\x9D\x88\x91"
  347.                "\xFF\xFF\xFF"
  348.                "\xFF\xFF\xFF"
  349.                "\xFF\xFF\xFF"
  350.                "\x47\x48\x37"
  351.                "\x7A\x5E\x55"
  352.                "\xDF\xD0\xAB"
  353.                "\xFF\xFB\xF9"
  354.                "\xE8\xCA\xC5"
  355.                "\x8A\x7C\x77";
  356.  
  357.         pat10="\xEE\xDD\xBB\xAA\x88\x77\x55\x44\x22\x11";
  358.  
  359. VAR     cnt: LONGINT;
  360.         r: INTEGER;
  361.         g: INTEGER;
  362.         b: INTEGER;
  363.         val: LONGINT;
  364.  
  365. BEGIN
  366. (* /// "$IF RUNDEBUG" *)
  367.   IF o.debug THEN d.PrintF("init default colormap\n"); END;
  368. (* \\\ $END *)
  369.   IF colorMap=NIL THEN NEW(colorMap); END;
  370.   IF depth=1 THEN
  371.     colorMap.colors[0].red:=0;
  372.     colorMap.colors[0].green:=0;
  373.     colorMap.colors[0].blue:=0;
  374.     colorMap.colors[1].red:=0FFFFFFFFH;
  375.     colorMap.colors[1].green:=0FFFFFFFFH;
  376.     colorMap.colors[1].blue:=0FFFFFFFFH;
  377.     cmap[0].red:=000X;
  378.     cmap[0].green:=000X;
  379.     cmap[0].blue:=000X;
  380.     cmap[1].red:=0FFX;
  381.     cmap[1].green:=0FFX;
  382.     cmap[1].blue:=0FFX;
  383.     colorMap.count:=2;
  384.     colorMap.first:=0;
  385.     colorMap.last:=1;
  386.   ELSIF depth=4 THEN
  387.     FOR cnt:=0 TO 14 DO
  388.       colorMap.colors[cnt].red:=i2m.ByteTo32(qt4map[cnt+0]);
  389.       colorMap.colors[cnt].green:=i2m.ByteTo32(qt4map[cnt+1]);
  390.       colorMap.colors[cnt].blue:=i2m.ByteTo32(qt4map[cnt+2]);
  391.       cmap[cnt].red:=qt4map[cnt+0];
  392.       cmap[cnt].green:=qt4map[cnt+1];
  393.       cmap[cnt].blue:=qt4map[cnt+2];
  394.     END;
  395.     colorMap.colors[15].red:=0;
  396.     colorMap.colors[15].green:=0;
  397.     colorMap.colors[15].blue:=0;
  398.     cmap[15].red:=000X;
  399.     cmap[15].green:=000X;
  400.     cmap[15].blue:=000X;
  401.     colorMap.count:=16;
  402.     colorMap.first:=0;
  403.     colorMap.last:=15;
  404.   ELSE
  405.     r:=0FFH;
  406.     g:=0FFH;
  407.     b:=0FFH;
  408.     FOR cnt:=0 TO 214 DO
  409.       colorMap.colors[cnt].red:=i2m.ByteTo32(CHR(r));
  410.       colorMap.colors[cnt].green:=i2m.ByteTo32(CHR(g));
  411.       colorMap.colors[cnt].blue:=i2m.ByteTo32(CHR(b));
  412.       cmap[cnt].red:=CHR(r);
  413.       cmap[cnt].green:=CHR(g);
  414.       cmap[cnt].blue:=CHR(b);
  415.       DEC(b,033H);
  416.       IF b<0 THEN
  417.         b:=0FFH;
  418.         DEC(g,033H);
  419.         IF g<0 THEN
  420.           g:=0FFH;
  421.           DEC(r,033H);
  422.         END;
  423.       END;
  424.     END;
  425.     FOR cnt:=0 TO 9 DO
  426.       val:=i2m.ByteTo32(pat10[cnt]);
  427.       colorMap.colors[215+cnt].red:=val;
  428.       colorMap.colors[215+cnt].green:=0;
  429.       colorMap.colors[215+cnt].blue:=0;
  430.       cmap[215+cnt].red:=CHR(val);
  431.       cmap[215+cnt].green:=000X;
  432.       cmap[215+cnt].blue:=000X;
  433.       colorMap.colors[225+cnt].red:=0;
  434.       colorMap.colors[225+cnt].green:=val;
  435.       colorMap.colors[225+cnt].blue:=0;
  436.       cmap[225+cnt].red:=000X;
  437.       cmap[225+cnt].green:=CHR(val);
  438.       cmap[225+cnt].blue:=000X;
  439.       colorMap.colors[235+cnt].red:=0;
  440.       colorMap.colors[235+cnt].green:=0;
  441.       colorMap.colors[235+cnt].blue:=val;
  442.       cmap[235+cnt].red:=000X;
  443.       cmap[235+cnt].green:=000X;
  444.       cmap[235+cnt].blue:=CHR(val);
  445.       colorMap.colors[245+cnt].red:=val;
  446.       colorMap.colors[245+cnt].green:=val;
  447.       colorMap.colors[245+cnt].blue:=val;
  448.       cmap[245+cnt].red:=CHR(val);
  449.       cmap[245+cnt].green:=CHR(val);
  450.       cmap[245+cnt].blue:=CHR(val);
  451.     END;
  452.     colorMap.colors[255].red:=0;
  453.     colorMap.colors[255].green:=0;
  454.     colorMap.colors[255].blue:=0;
  455.     cmap[255].red:=000X;
  456.     cmap[255].green:=000X;
  457.     cmap[255].blue:=000X;
  458.     colorMap.count:=256;
  459.     colorMap.first:=0;
  460.     colorMap.last:=255;
  461.   END;
  462. END InitDefColorMap;
  463. (* \\\ ------------------------------------------------------------------------- *)
  464.  
  465. (* /// -------------------- "PROCEDURE InitGrayColorMap()" --------------------- *)
  466. PROCEDURE InitGrayColorMap(depth: LONGINT;
  467.                            backward: BOOLEAN);
  468.  
  469. VAR     cnt: LONGINT;
  470.         g: LONGINT;
  471.         gray: CHAR;
  472.  
  473. BEGIN
  474. (* /// "$IF RUNDEBUG" *)
  475.   IF o.debug THEN d.PrintF("init gray colormap\n"); END;
  476. (* \\\ $END *)
  477.   IF colorMap=NIL THEN NEW(colorMap); END;
  478.   IF depth=36 THEN
  479.     FOR cnt:=0 TO 15 DO
  480.       gray:=CHR((15-cnt)*17);
  481.       g:=i2m.ByteTo32(gray);
  482.       colorMap.colors[cnt].red:=g;
  483.       colorMap.colors[cnt].green:=g;
  484.       colorMap.colors[cnt].blue:=g;
  485.       cmap[cnt].red:=gray;
  486.       cmap[cnt].green:=gray;
  487.       cmap[cnt].blue:=gray;
  488.     END;
  489.     colorMap.count:=16;
  490.     colorMap.first:=0;
  491.     colorMap.last:=15;
  492.   ELSE
  493.     FOR cnt:=0 TO 255 DO
  494.       IF backward THEN
  495.         gray:=CHR(255-cnt);
  496.       ELSE
  497.         gray:=CHR(cnt);
  498.       END;
  499.       g:=i2m.ByteTo32(gray);
  500.       colorMap.colors[cnt].red:=g;
  501.       colorMap.colors[cnt].green:=g;
  502.       colorMap.colors[cnt].blue:=g;
  503.       cmap[cnt].red:=gray;
  504.       cmap[cnt].green:=gray;
  505.       cmap[cnt].blue:=gray;
  506.     END;
  507.     colorMap.count:=256;
  508.     colorMap.first:=0;
  509.     colorMap.last:=255;
  510.   END;
  511.   grayScale:=TRUE;
  512. END InitGrayColorMap;
  513. (* \\\ ------------------------------------------------------------------------- *)
  514.  
  515. (* /// ---------------------- "PROCEDURE InitColorMap()" ----------------------- *)
  516. PROCEDURE InitColorMap * (desc: g.VideoDescriptionPtr);
  517.  
  518. TYPE    Color=STRUCT
  519.             p: INTEGER;
  520.             r: INTEGER;
  521.             g: INTEGER;
  522.             b: INTEGER;
  523.         END;
  524.         ColorArray=UNTRACED POINTER TO ARRAY MAX(INTEGER) OF Color;
  525.  
  526. VAR     cnt: LONGINT;
  527.         grayColor: LONGINT;
  528.         gray: CHAR;
  529.         colorCnt: LONGINT;
  530.         start: LONGINT;
  531.         end: LONGINT;
  532.         data: ColorArray;
  533.  
  534. BEGIN
  535.   IF (desc.depth<=8) OR (desc.depth>32) THEN
  536.     IF colorMap=NIL THEN NEW(colorMap); END;
  537.     IF (desc.depth<32) & ~grayScale THEN
  538.       InitDefColorMap(desc.depth);
  539.     ELSE
  540.       InitGrayColorMap(desc.depth,(desc.head.dataFormat#idcvid) & (desc.head.dataFormat#idCVID) & (desc.head.dataFormat#idjpeg));
  541.     END;
  542.     IF ~(3 IN y.VAL(SET,desc.colorTableID)) & (desc.head.size>86) THEN
  543. (* /// "$IF RUNDEBUG" *)
  544.       IF o.debug THEN d.PrintF("init own colormap\n"); END;
  545. (* \\\ $END *)
  546.       start:=desc.start;
  547.       end:=desc.end;
  548. (* normalerweise müßten diese Werte gesetzt werden, aber bei zB 247 Farben gibts Murx. *Kein* Fehler von CGX, tritt auch bei AGA-only auf
  549.       colorMap.count:=i.LongToUInt(end-start+1);
  550.       colorMap.first:=i.LongToUInt(start);
  551.       colorMap.last:=end;
  552. *)
  553.       data:=y.ADR(desc.colorTable);
  554.       FOR cnt:=start TO end DO
  555.         IF grayScale THEN
  556.           data[cnt].r:=y.LSH(data[cnt].r,-8);
  557.           data[cnt].g:=y.LSH(data[cnt].g,-8);
  558.           data[cnt].b:=y.LSH(data[cnt].b,-8);
  559.           gray:=CHR(y.LSH(data[cnt].r*11+data[cnt].g*16+data[cnt].g*5,-5));
  560.           grayColor:=i2m.ByteTo32(gray);
  561.           colorMap.colors[cnt].red:=grayColor;
  562.           colorMap.colors[cnt].green:=grayColor;
  563.           colorMap.colors[cnt].blue:=grayColor;
  564.           cmap[cnt].red:=gray;
  565.           cmap[cnt].green:=gray;
  566.           cmap[cnt].blue:=gray;
  567.         ELSE
  568.           colorMap.colors[cnt].red:=i2m.ShortTo32(data[cnt].r);
  569.           colorMap.colors[cnt].green:=i2m.ShortTo32(data[cnt].g);
  570.           colorMap.colors[cnt].blue:=i2m.ShortTo32(data[cnt].b);
  571.           cmap[cnt].red:=CHR(y.LSH(data[cnt].r,-8));
  572.           cmap[cnt].green:=CHR(y.LSH(data[cnt].g,-8));
  573.           cmap[cnt].blue:=CHR(y.LSH(data[cnt].b,-8));
  574.         END;
  575.       END;
  576.     END;
  577.   END;
  578. END InitColorMap;
  579. (* \\\ ------------------------------------------------------------------------- *)
  580.  
  581. (* /// ---------------------- "PROCEDURE InitTmpBitMap()" ---------------------- *)
  582. PROCEDURE InitTmpBitMap(): LONGINT;
  583. BEGIN
  584.   tmpBM:=gfx.AllocBitMap(animWidth,animHeight,mu.max(animDepth,4),LONGSET{gfx.bmbInterleaved},NIL);
  585.   IF tmpBM=NIL THEN RETURN d.noFreeStore; END;
  586.   IF ~(gfx.bmbInterleaved IN y.VAL(LONGSET,gfx.GetBitMapAttr(tmpBM,gfx.bmaFlags))) THEN RETURN d.noFreeStore; END;
  587.   IF tmpRas=NIL THEN (* tmpRas nur einmal allokieren *)
  588.     NEW(tmpRas);
  589.     INCL(ol.MemReqs,e.chip);
  590.     NEW(tmpRasMem);
  591.     EXCL(ol.MemReqs,e.chip);
  592.     gfx.InitTmpRas(tmpRas^,tmpRasMem,tmpRasSize);
  593.   END;
  594.   rp.tmpRas:=y.ADR(tmpRas);
  595.   RETURN g.noError;
  596. END InitTmpBitMap;
  597. (* \\\ ------------------------------------------------------------------------- *)
  598.  
  599. (* /// --------------------- "PROCEDURE DetermineDepth()" ---------------------- *)
  600. PROCEDURE DetermineDepth();
  601.  
  602. VAR     track: g.TrackPtr;
  603.         usage: LONGINT;
  604.  
  605. BEGIN
  606.   track:=g.animInfo.videoTracks.head;
  607.   usage:=0;
  608.   WHILE track.node.succ#NIL DO
  609.     IF track.sizeEntries>usage THEN
  610.       animDepth:=y.VAL(g.VideoDescriptionPtr,track.descriptions[track.descriptionEntries-1]).depth;
  611.       usage:=track.sizeEntries;
  612.     ELSE
  613.       IF y.VAL(g.VideoDescriptionPtr,track.descriptions[track.descriptionEntries-1]).depth>32 THEN grayScale:=TRUE; END;
  614.     END;
  615.     track:=track.node.succ;
  616.   END;
  617.   IF animDepth>32 THEN
  618.     grayScale:=TRUE;
  619.     DEC(animDepth,32);
  620.   END;
  621. END DetermineDepth;
  622. (* \\\ ------------------------------------------------------------------------- *)
  623.  
  624. (* /// ---------------------- "PROCEDURE CloseDisplay()" ----------------------- *)
  625. PROCEDURE CloseDisplay * ();
  626. BEGIN
  627.   IF tmpRas#NIL THEN gfx.WaitBlit(); rp.tmpRas:=NIL; END;
  628.   IF window#NIL THEN i.CloseWindow(window); window:=NIL; END;
  629.   IF screen#NIL THEN
  630.     IF pubScreen THEN
  631.       i.UnlockPubScreen(NIL,screen);
  632.     ELSE
  633.       i.OldCloseScreen(screen);
  634.     END;
  635.     screen:=NIL;
  636.   END;
  637.   IF mouse#NIL THEN i.DisposeObject(mouse); mouse:=NIL; END;
  638.   IF mouseBitMap#NIL THEN gfx.FreeBitMap(mouseBitMap); mouseBitMap:=NIL; END;
  639.   IF tmpBM#NIL THEN gfx.FreeBitMap(tmpBM); tmpBM:=NIL; END;
  640. END CloseDisplay;
  641. (* \\\ ------------------------------------------------------------------------- *)
  642.  
  643. (* /// ----------------------- "PROCEDURE OpenDisplay()" ----------------------- *)
  644. PROCEDURE OpenDisplay * (virtual: BOOLEAN;
  645.                          fileTitle: e.STRPTR): LONGINT;
  646.  
  647. VAR     windowTags: u.Tags20;
  648.         screenDepth: LONGINT;
  649.         errVal: LONGINT;
  650.         cgx3: e.LibraryPtr;
  651.  
  652. CONST   winLeft=0;
  653.         winTop=1;
  654.         winWidth=2;
  655.         winHeight=3;
  656.         winScreen=4;
  657.  
  658. (* /// ---------------------- "PROCEDURE InitPubScreen()" ---------------------- *)
  659.   PROCEDURE InitPubScreen(): LONGINT;
  660.  
  661.   VAR   width: LONGINT;
  662.         height: LONGINT;
  663.         factor: REAL;
  664.  
  665.   CONST winTitle=6;
  666.         winMaxW=7;
  667.         winMaxH=8;
  668.         winMinW=9;
  669.         winMinH=10;
  670.         winSizeGad=15;
  671.  
  672.   BEGIN
  673.     windowTags:=u.Tags20(i.waLeft,0,
  674.                          i.waTop,0,
  675.                          i.waInnerWidth,0,
  676.                          i.waInnerHeight,0,
  677.                          i.waPubScreen,NIL,
  678.                          i.waActivate,e.true,
  679.                          i.waTitle,NIL,
  680.                          i.waMaxWidth,-1,
  681.                          i.waMaxHeight,-1,
  682.                          i.waMinWidth,-1,
  683.                          i.waMinHeight,-1,
  684.                          i.waDragBar,e.true,
  685.                          i.waDepthGadget,e.true,
  686.                          i.waCloseGadget,e.true,
  687.                          i.waAutoAdjust,e.true,
  688.                          i.waSizeGadget,e.true,
  689.                          i.waSizeBBottom,e.true,
  690.                          i.waRMBTrap,e.true,
  691.                          i.waIDCMP,LONGSET{i.closeWindow,i.vanillaKey,i.rawKey},
  692.                          u.done,0);
  693.     screen:=i.LockPubScreen(o.pubScreen);
  694.     IF screen=NIL THEN
  695.       d.PrintF("Can't find screen \"%s\", using own screen.\n",y.ADR(o.pubScreen));
  696.       RETURN g.unknownError;
  697.     END;
  698.     width:=gfx.GetBitMapAttr(screen.rastPort.bitMap,gfx.bmaWidth);
  699.     height:=gfx.GetBitMapAttr(screen.rastPort.bitMap,gfx.bmaHeight);
  700.     screenDepth:=gfx.GetBitMapAttr(screen.rastPort.bitMap,gfx.bmaDepth);
  701.     IF (width<calcWidth) OR (height<calcHeight) THEN
  702.       d.PrintF("Screen is too small, using own screen.\n");
  703.       RETURN g.unknownError;
  704.     END;
  705.     IF screenDepth<15 THEN
  706.       d.PrintF("Screen \"%s\" is not a truecolor screen, using own screen.\n",y.ADR(o.pubScreen));
  707.       RETURN g.unknownError;
  708.     END;
  709.     IF ~cgfx.IsCyberModeID(gfx.GetVPModeID(y.ADR(screen.viewPort))) THEN
  710.       d.PrintF("Screen \"%s\" is not a CyberGraphX native screen, using own screen.\n",y.ADR(o.pubScreen));
  711.       RETURN g.unknownError;
  712.     END;
  713.  
  714.     IF o.magnify<0 THEN
  715.       factor:=1/(-o.magnify);
  716.     ELSE
  717.       factor:=o.magnify;
  718.     END;
  719.     IF (animDepth<=8) & grayScale THEN (* 8bit Graustufen => Truecolor *)
  720.       windowTags[winSizeGad].data:=e.false;
  721.       factor:=1.0;
  722.     END;
  723.     doubleScanned:=FALSE;
  724.     width:=mu.floor(animWidth*factor);
  725.     height:=mu.floor(animHeight*factor);
  726.     windowTags[winLeft].data:=(screen.width-width) DIV 2;
  727.     windowTags[winTop].data:=(screen.height-height) DIV 2;
  728.     windowTags[winWidth].data:=width;
  729.     windowTags[winHeight].data:=height;
  730.     windowTags[winTitle].data:=fileTitle;
  731.     windowTags[winMaxW].data:=animWidth*4;
  732.     windowTags[winMaxH].data:=animHeight*4;
  733.     windowTags[winMinW].data:=animWidth DIV 4;
  734.     windowTags[winMinH].data:=animHeight DIV 4;
  735.     i.ScreenToFront(screen);
  736.     doubleScanned:=FALSE;
  737.     RETURN g.noError;
  738.   END InitPubScreen;
  739. (* \\\ ------------------------------------------------------------------------- *)
  740.  
  741. (* /// ---------------------- "PROCEDURE InitOwnScreen()" ---------------------- *)
  742.   PROCEDURE InitOwnScreen(): LONGINT;
  743.  
  744.   VAR   screenTags: u.Tags12;
  745.         dispIDbyDim: LONGINT;
  746.         dispID: LONGINT;
  747.         dimInfo: gfx.DimensionInfo;
  748.         dispInfo: gfx.DisplayInfo;
  749.         nameInfo: gfx.NameInfo;
  750.         error: LONGINT;
  751.  
  752.   CONST scrID=0;
  753.         scrWidth=1;
  754.         scrHeight=2;
  755.         scrDepth=3;
  756.         scrColors=4;
  757.         scrErrorCode=5;
  758.         scrInterleaved=6;
  759.         winPointer=5;
  760.  
  761.   BEGIN
  762.     windowTags:=u.Tags20(i.waLeft,0,
  763.                          i.waTop,0,
  764.                          i.waInnerWidth,0,
  765.                          i.waInnerHeight,0,
  766.                          i.waCustomScreen,NIL,
  767.                          i.waPointer,NIL,
  768.                          i.waActivate,e.true,
  769.                          i.waAutoAdjust,e.true,
  770.                          i.waBorderless,e.true,
  771.                          i.waRMBTrap,e.true,
  772.                          i.waIDCMP,LONGSET{i.mouseButtons,i.vanillaKey,i.rawKey},
  773.                          u.done,0,
  774.                          0,0,
  775.                          0,0,
  776.                          0,0,
  777.                          0,0,
  778.                          0,0,
  779.                          0,0,
  780.                          0,0,
  781.                          0,0);
  782.     screenTags:=u.Tags12(i.saDisplayID,0,
  783.                          i.saWidth,0,
  784.                          i.saHeight,0,
  785.                          i.saDepth,0,
  786.                          i.saColors32,NIL,
  787.                          i.saErrorCode,NIL,
  788.                          i.saInterleaved,e.false,
  789.                          i.saTitle,y.ADR("CyberQT"),
  790.                          i.saBehind,e.false,
  791.                          i.saQuiet,e.true,
  792.                          i.saPens,y.ADR("\x00\x00"
  793.                                         "\x00\x00"
  794.                                         "\x00\x00"
  795.                                         "\x00\x00"
  796.                                         "\x00\x00"
  797.                                         "\x00\x00"
  798.                                         "\x00\x00"
  799.                                         "\x00\x00"
  800.                                         "\x00\x00"
  801.                                         "\x00\x00"
  802.                                         "\x00\x00"
  803.                                         "\x00\x00"
  804.                                         "\xFF\xFF"),
  805.                          u.done,0);
  806.     
  807.     IF (animDepth>8) & (colorReduction OR ham8) THEN
  808.       animDepth:=8;
  809.       IF ham8 THEN
  810.         InitHAM8ColorMap();
  811.       ELSE
  812.         Init332ColorMap();
  813.       END;
  814.     END;
  815.  
  816.     IF (animDepth>8) & o.force24 THEN animDepth:=24; END;
  817.  
  818.     IF o.screenModeID#0 THEN
  819.       dispIDbyDim:=o.screenModeID;
  820.     ELSE
  821.       dispIDbyDim:=b.BestMode(animWidth,animHeight,animDepth,colorReduction,ham8);
  822.     END;
  823.     dispID:=dispIDbyDim;
  824. (* /// "$IF RUNDEBUG" *)
  825.     IF o.debug THEN
  826.        y.SETREG(0,gfx.GetDisplayInfoData(NIL,nameInfo,SIZE(nameInfo),gfx.dtagName,dispID));
  827.        d.PrintF("selected screenmode: %s ($%08lx)\n",y.ADR(nameInfo.name),dispID);
  828.     END;
  829. (* \\\ $END *)
  830.  
  831.     IF o.askScrMode OR (dispID=gfx.invalidID) THEN
  832. (* /// "$IF RUNDEBUG" *)
  833.       IF o.debug & (dispID=gfx.invalidID) THEN d.PrintF("invalid display id, prompting for screenmode\n"); END;
  834. (* \\\ "$END" *)
  835.       dispID:=b.SelectModeIDByReq(animWidth,animHeight,animDepth,dispIDbyDim,colorReduction,ham8);
  836.     END;
  837.  
  838.     IF dispID=gfx.invalidID THEN
  839.       IF dispIDbyDim=gfx.invalidID THEN
  840. (* /// "$IF RUNDEBUG" *)
  841.         IF o.debug THEN d.PrintF("invalid display id, selecting simple id\n"); END;
  842. (* \\\ "$END" *)
  843.         dispID:=b.SelectModeIDSimple(animWidth,animHeight,ham8);
  844.       ELSE
  845.         dispID:=dispIDbyDim;
  846.       END;
  847.     END;
  848.  
  849.     screenTags[scrID].data:=dispID;
  850.     IF colorReduction OR ham8 THEN
  851.       y.SETREG(0,gfx.GetDisplayInfoData(NIL,dimInfo,SIZE(dimInfo),gfx.dtagDims,dispID));
  852.       screenDepth:=dimInfo.maxDepth;
  853.       screenTags[scrWidth].data:=dimInfo.nominal.maxX-dimInfo.nominal.minX+1;
  854.       screenTags[scrHeight].data:=dimInfo.nominal.maxY-dimInfo.nominal.minY+1;
  855.       screenTags[scrDepth].data:=mu.max(animDepth,4); (* unter AGA besser minimale Plane-Anzahl nehmen... *)
  856.       screenTags[scrInterleaved].data:=e.true;
  857.     ELSE
  858.       screenDepth:=cgfx.GetCyberIDAttr(cgfx.idAttrDepth,dispID);
  859.       screenTags[scrWidth].data:=cgfx.GetCyberIDAttr(cgfx.idAttrWidth,dispID);
  860.       screenTags[scrHeight].data:=cgfx.GetCyberIDAttr(cgfx.idAttrHeight,dispID);
  861.       screenTags[scrDepth].data:=screenDepth; (* ... aber unter CyberGfx besser 8bpp *)
  862.     END;
  863.     IF animDepth<=8 THEN screenTags[scrColors].data:=colorMap; END;
  864.     screenTags[scrErrorCode].data:=y.ADR(error);
  865.     screen:=i.OpenScreenTagListA(NIL,screenTags);
  866.     IF screen=NIL THEN
  867.       d.PrintF("Can't open screen: ");
  868.       CASE error OF
  869.       | i.osErrNoMem: d.PrintF("not enough memory\n");
  870.       | i.osErrNoChipMem: d.PrintF("not enough chip memory\n");
  871.       | i.osErrUnknownMode: d.PrintF("unknown display id $%08lx\n",dispID);
  872.       | i.oserrTooDeep: d.PrintF("depth %ld is too high\n",screenDepth);
  873.       | i.oserrNotAvailable: d.PrintF("mode $%08lx is not available\n",dispID);
  874.       ELSE
  875.         d.PrintF("unknown error\n");
  876.       END;
  877.       RETURN g.unknownError;
  878.     END;
  879.     y.SETREG(0,gfx.GetDisplayInfoData(NIL,dispInfo,SIZE(dispInfo),gfx.dtagDisp,dispID));
  880.     doubleScanned:=(gfx.isScandbl IN dispInfo.propertyFlags);
  881.     mouseBitMap:=gfx.AllocBitMap(16,1,2,LONGSET{gfx.bmbClear,gfx.bmbDisplayable},NIL); (* Pointer mit 16x1 Pixel und 2 Planes *)
  882.     IF mouseBitMap#NIL THEN
  883.       mouse:=i.NewObject(NIL,i.pointerClass,i.pointeraBitMap,mouseBitMap,
  884.                                             u.done);
  885.     ELSE
  886.       mouse:=NIL;
  887.     END;
  888.     windowTags[winWidth].data:=screen.width;
  889.     windowTags[winHeight].data:=screen.height;
  890.     windowTags[winPointer].data:=mouse;
  891.     RETURN g.noError;
  892.   END InitOwnScreen;
  893. (* \\\ ------------------------------------------------------------------------- *)
  894.  
  895. BEGIN
  896.   doubleScanned:=TRUE;
  897.   IF virtual THEN RETURN g.noError; END;
  898.   errVal:=g.noError;
  899.   pubScreen:=(o.pubScreen#"");
  900.   cgx3:=e.OpenLibrary("cgxsystem.library",41);
  901.   IF pubScreen & (animDepth<=8) THEN
  902.     IF ~lv.CheckVersion(cgx3,41,9) THEN
  903.       pubScreen:=FALSE;
  904.       d.PrintF("Playback on public truecolor screens requires either truecolor animations (with\n"
  905.                "CyberGraphX V2), or CyberGraphX V3 (at least rev 41.9)!\n"
  906.                "Using own screen instead.\n");
  907.     END;
  908.   END;
  909.   IF cgx3#NIL THEN e.CloseLibrary(cgx3); END;
  910.   IF pubScreen THEN
  911.     IF InitPubScreen()#g.noError THEN
  912.       CloseDisplay();
  913.       pubScreen:=FALSE;
  914.       errVal:=InitOwnScreen();
  915.     END;
  916.   ELSE
  917.     errVal:=InitOwnScreen();
  918.   END;
  919.  
  920.   IF errVal=g.noError THEN
  921.     windowTags[winScreen].data:=screen;
  922.     window:=i.OpenWindowTagListA(NIL,windowTags);
  923.     IF window=NIL THEN
  924.       d.PrintF("Can't open window!\n");
  925.       RETURN g.unknownError;
  926.     END;
  927.     rp:=window.rPort;
  928.     idcmpSig:=window.userPort.sigBit;
  929.     IF pubScreen THEN
  930.       leftOff:=window.borderLeft;
  931.       topOff:=window.borderTop;
  932.     ELSE
  933.       leftOff:=i.LongToUInt((window.width-animWidth) DIV 2);
  934.       topOff:=i.LongToUInt((window.height-animHeight) DIV 2);
  935.       IF screenDepth<15 THEN
  936.         gfx.SetRast(y.ADR(screen.rastPort),0);
  937.         gfx.SetRast(rp,0);
  938.       ELSE
  939.         y.SETREG(0,cgfx.FillPixelArray(y.ADR(screen.rastPort),0,0,screen.width,screen.height,0));
  940.         y.SETREG(0,cgfx.FillPixelArray(rp,0,0,window.width,window.height,0));
  941.       END;
  942.     END;
  943.  
  944.     IF screenDepth<15 THEN
  945.       IF colorReduction THEN
  946.         errVal:=InitTmpBitMap(); (* die AGA-Routine braucht eine extra BitMap *)
  947.       END;
  948.     END;
  949.   END;
  950.   RETURN errVal;
  951. END OpenDisplay;
  952. (* \\\ ------------------------------------------------------------------------- *)
  953.  
  954. (* /// ----------------------- "PROCEDURE DecodeDummy()" ----------------------- *)
  955. PROCEDURE DecodeDummy {"_DecodeDummy"} (from{8}: e.APTR;
  956.                                         to{9}: e.APTR;
  957.                                         width{0}: LONGINT;
  958.                                         height{1}: LONGINT;
  959.                                         encSize{2}: LONGINT;
  960.                                         spec{10}: e.APTR);
  961.  
  962. PROCEDURE SetupDummy(VAR codec: CodecHeader);
  963. BEGIN
  964.   codec.decoder:=DecodeDummy;
  965.   codec.special:=NIL;
  966. END SetupDummy;
  967. (* \\\ ------------------------------------------------------------------------- *)
  968.  
  969. (* /// ---------------------------- "TYPE CVIDData" ---------------------------- *)
  970. TYPE    Color2x2Ptr=UNTRACED POINTER TO Color2x2;
  971.         Color2x2=STRUCT
  972.             r0,g0,b0: CHAR;
  973.             r1,g1,b1: CHAR;
  974.             r2,g2,b2: CHAR;
  975.             r3,g3,b3: CHAR;
  976.             clr00, clr01, clr02, clr03: LONGINT;
  977.             clr10, clr11, clr12, clr13: LONGINT;
  978.             clr20, clr21, clr22, clr23: LONGINT;
  979.             clr30, clr31, clr32, clr33: LONGINT;
  980.         END;
  981.         Color2x2ArrayPtr=UNTRACED POINTER TO Color2x2Array;
  982.         Color2x2Array=ARRAY 256 OF Color2x2;
  983.  
  984. CONST   cvidMaxStrips=16;
  985.  
  986. TYPE    CVIDDataPtr=UNTRACED POINTER TO CVIDData;
  987.         CVIDData=STRUCT
  988.             gray: BOOLEAN;
  989.             dither: BOOLEAN;
  990.             cvidMaps0: ARRAY cvidMaxStrips OF Color2x2ArrayPtr;
  991.             cvidMaps1: ARRAY cvidMaxStrips OF Color2x2ArrayPtr;
  992.             vMap0: ARRAY cvidMaxStrips OF LONGINT;
  993.             vMap1: ARRAY cvidMaxStrips OF LONGINT;
  994.             yuv: ys.YUVTablePtr;
  995.             limit: ys.RangeLimitPtr;
  996.             cmap: CMapArrPtr;
  997.         END;
  998.  
  999. VAR     cvidData: CVIDDataPtr;
  1000. (* \\\ ------------------------------------------------------------------------- *)
  1001.  
  1002. (* /// ----------------------- "PROCEDURE DecodeCVID()" ------------------------ *)
  1003. PROCEDURE DecodeCVID {"_DecodeCVID"} (from{8}: e.APTR;
  1004.                                       to{9}: e.APTR;
  1005.                                       width{0}: LONGINT;
  1006.                                       height{1}: LONGINT;
  1007.                                       encSize{2}: LONGINT;
  1008.                                       spec{10}: e.APTR);
  1009.  
  1010. PROCEDURE SelectCVIDFuncs {"_SelectCVIDFuncs"} (spec{8}: CVIDDataPtr;
  1011.                                                 reduce{0}: BOOLEAN;
  1012.                                                 dither{1}: BOOLEAN);
  1013.  
  1014. PROCEDURE SetupCVID(VAR codec: CodecHeader);
  1015.  
  1016. VAR     cnt: LONGINT;
  1017.  
  1018. BEGIN
  1019.   IF cvidData=NIL THEN
  1020.     NEW(cvidData);
  1021.     FOR cnt:=0 TO cvidMaxStrips-1 DO
  1022.       NEW(cvidData.cvidMaps0[cnt]);
  1023.       NEW(cvidData.cvidMaps1[cnt]);
  1024.     END;
  1025.   END;
  1026.   cvidData.gray:=grayScale;
  1027.   cvidData.yuv:=ys.GenYUVTables();
  1028.   cvidData.limit:=ys.InitLimitTables();
  1029.   cvidData.cmap:=cmap;
  1030.   SelectCVIDFuncs(cvidData,(colorReduction & ~ham8) OR grayScale,o.dither);
  1031.   codec.decoder:=DecodeCVID;
  1032.   codec.special:=cvidData;
  1033. END SetupCVID;
  1034. (* \\\ ------------------------------------------------------------------------- *)
  1035.  
  1036. (* /// ---------------------------- "TYPE JPEGData" ---------------------------- *)
  1037. TYPE    JPEGDataPtr=UNTRACED POINTER TO JPEGData;
  1038.         JPEGData=STRUCT
  1039.             gray: BOOLEAN;
  1040.             dither: BOOLEAN;
  1041.             yuvTab: ys.YUVTablePtr;
  1042.             yuvBuf: ys.YUVBufferPtr;
  1043.             limit: ys.RangeLimitPtr;
  1044.             quantTab: ARRAY 4 OF e.APTR;
  1045.             cmap: CMapArrPtr;
  1046.             test: LONGINT;
  1047.         END;
  1048.  
  1049. VAR     jpegData: JPEGDataPtr;
  1050. (* \\\ ------------------------------------------------------------------------- *)
  1051.  
  1052. (* /// ----------------------- "PROCEDURE DecodeJPEG()" ------------------------ *)
  1053. PROCEDURE DecodeJPEG {"_DecodeJPEG"} (from{8}: e.APTR;
  1054.                                       to{9}: e.APTR;
  1055.                                       width{0}: LONGINT;
  1056.                                       height{1}: LONGINT;
  1057.                                       encSize{2}: LONGINT;
  1058.                                       spec{10}: e.APTR);
  1059.  
  1060. PROCEDURE SelectJPEGFuncs {"_SelectJPEGFuncs"} (spec{8}: JPEGDataPtr;
  1061.                                                 reduce{0}: BOOLEAN;
  1062.                                                 dither{1}: BOOLEAN);
  1063. (* ///
  1064. PROCEDURE DecodeJPEG (from{8}: e.APTR;
  1065.                       to{9}: e.APTR;
  1066.                       width{0}: LONGINT;
  1067.                       height{1}: LONGINT;
  1068.                       encSize{2}: LONGINT;
  1069.                       spec{10}: e.APTR);
  1070.  
  1071. TYPE    arr=UNTRACED POINTER TO ARRAY MAX(INTEGER) OF LONGINT;
  1072.  
  1073. VAR     o: i.ObjectPtr;
  1074.         file: e.STRING;
  1075.         fh: d.FileHandlePtr;
  1076.         bm: gfx.BitMapPtr;
  1077.         mode: LONGINT;
  1078.         tcmap: arr;
  1079.  
  1080. BEGIN
  1081.   sl.sprintf(file,"T:CyberQT1.%08lx.temp",e.FindTask(NIL));
  1082.   fh:=d.Open(file,d.newFile);
  1083.   IF fh#NIL THEN
  1084.     y.SETREG(0,d.Write(fh,y.VAL(e.LSTRPTR,from)^,encSize));
  1085.     d.OldClose(fh);
  1086.     IF colorReduction THEN mode:=dt.modeV42; ELSE mode:=dt.modeV43; END;
  1087.     o:=dt.NewDTObject(file,dt.destMode,mode,
  1088.                            u.done);
  1089.     IF o#NIL THEN
  1090.       IF mode=dt.modeV42 THEN
  1091.         y.SETREG(0,dt.GetDTAttrs(o,dt.bitMap,y.ADR(bm),
  1092.                                    dt.cRegs,y.ADR(tcmap),
  1093.                                    u.done));
  1094.         gfx.LoadRGB32(y.ADR(screen.viewPort),tcmap^);
  1095.       ELSE
  1096.         y.SETREG(0,dt.GetDTAttrs(o,dt.bitMap,y.ADR(bm),u.done));
  1097.       END;
  1098.       gfx.BltBitMapRastPort(bm,0,0,rp,leftOff,topOff,animWidth,animHeight,y.VAL(y.BYTE,0C0H));
  1099.       dt.DisposeDTObject(o);
  1100.     END;
  1101.   END;
  1102. END DecodeJPEG;
  1103.  
  1104. PROCEDURE DecodeJPEGlib (from{8}: e.APTR;
  1105.                          to{9}: e.APTR;
  1106.                          width{0}: LONGINT;
  1107.                          height{1}: LONGINT;
  1108.                          encSize{2}: LONGINT;
  1109.                          spec{10}: e.APTR);
  1110. BEGIN
  1111.   jpegData.handle.fromBuffer:=videoData;
  1112.   jpegData.handle.toBuffer:=videoDataDec;
  1113.   jpegData.handle.encodedSize:=encSize;
  1114.   jpeg.DecodeJPEG(y.ADR(jpegData.handle));
  1115. END DecodeJPEGlib;
  1116. \\\ *)
  1117.  
  1118. PROCEDURE SetupJPEG(VAR codec: CodecHeader);
  1119.  
  1120. VAR     cnt: LONGINT;
  1121.  
  1122. BEGIN
  1123.   IF jpegData=NIL THEN
  1124.     NEW(jpegData);
  1125.     FOR cnt:=0 TO 3 DO ol.New(jpegData.quantTab[cnt],64*SIZE(LONGINT)); END;
  1126.   END;
  1127.   jpegData.gray:=grayScale;
  1128.   jpegData.yuvTab:=ys.GenYUVTables();
  1129.   jpegData.yuvBuf:=ys.AllocMCUBuffers(codec.width,codec.height);
  1130.   jpegData.limit:=ys.InitLimitTables();
  1131.   jpegData.cmap:=cmap;
  1132.   SelectJPEGFuncs(jpegData,(colorReduction & ~ham8) OR grayScale,o.dither);
  1133.   codec.decoder:=DecodeJPEG;
  1134.   codec.special:=jpegData;
  1135. END SetupJPEG;
  1136. (* \\\ ------------------------------------------------------------------------- *)
  1137.  
  1138. (* /// ---------------------------- "TYPE KPCDData" ---------------------------- *)
  1139. TYPE    KPCDDataPtr=UNTRACED POINTER TO KPCDData;
  1140.         KPCDData=STRUCT
  1141.             gray: BOOLEAN;
  1142.             yuvTab: ys.YUVTablePtr;
  1143.             limit: ys.RangeLimitPtr;
  1144.             cmap: CMapArrPtr;
  1145.         END;
  1146.  
  1147. VAR     kpcdData: KPCDDataPtr;
  1148. (* \\\ ------------------------------------------------------------------------- *)
  1149.  
  1150. (* /// ----------------------- "PROCEDURE DecodeKPCD()" ------------------------ *)
  1151. PROCEDURE DecodeKPCD {"_DecodeKPCD"} (from{8}: e.APTR;
  1152.                                       to{9}: e.APTR;
  1153.                                       width{0}: LONGINT;
  1154.                                       height{1}: LONGINT;
  1155.                                       encSize{2}: LONGINT;
  1156.                                       spec{10}: e.APTR);
  1157.  
  1158. PROCEDURE SelectKPCDFuncs {"_SelectKPCDFuncs"} (spec{8}: KPCDDataPtr;
  1159.                                                 reduce{0}: BOOLEAN;
  1160.                                                 dither{1}: BOOLEAN);
  1161.  
  1162. PROCEDURE SetupKPCD(VAR codec: CodecHeader);
  1163. BEGIN
  1164.   IF kpcdData=NIL THEN NEW(kpcdData); END;
  1165.   kpcdData.gray:=grayScale;
  1166.   kpcdData.yuvTab:=ys.GenYUVTables();
  1167.   kpcdData.limit:=ys.InitLimitTables();
  1168.   kpcdData.cmap:=cmap;
  1169.   SelectKPCDFuncs(kpcdData,(colorReduction & ~ham8) OR grayScale,o.dither);
  1170.   codec.decoder:=DecodeKPCD;
  1171.   codec.special:=kpcdData;
  1172. END SetupKPCD;
  1173. (* \\\ ------------------------------------------------------------------------- *)
  1174.  
  1175. (* /// ---------------------------- "TYPE MJPAData" ---------------------------- *)
  1176. TYPE    MJPADataPtr=UNTRACED POINTER TO MJPAData;
  1177.         MJPAData=STRUCT
  1178.             gray: BOOLEAN;
  1179.             dither: BOOLEAN;
  1180.             yuvTab: ys.YUVTablePtr;
  1181.             yuvBuf: ys.YUVBufferPtr;
  1182.             limit: ys.RangeLimitPtr;
  1183.             quantTab: ARRAY 4 OF e.APTR;
  1184.             cmap: CMapArrPtr;
  1185.         END;
  1186.  
  1187. VAR     mjpaData: MJPADataPtr;
  1188. (* \\\ ------------------------------------------------------------------------- *)
  1189.  
  1190. (* /// ----------------------- "PROCEDURE DecodeMJPA()" ------------------------ *)
  1191. PROCEDURE DecodeMJPA {"_DecodeMJPA"} (from{8}: e.APTR;
  1192.                                       to{9}: e.APTR;
  1193.                                       width{0}: LONGINT;
  1194.                                       height{1}: LONGINT;
  1195.                                       encSize{2}: LONGINT;
  1196.                                       spec{10}: e.APTR);
  1197.  
  1198. PROCEDURE SelectMJPAFuncs {"_SelectMJPAFuncs"} (spec{8}: MJPADataPtr;
  1199.                                                 reduce{0}: BOOLEAN;
  1200.                                                 dither{1}: BOOLEAN);
  1201.  
  1202. PROCEDURE SetupMJPA(VAR codec: CodecHeader);
  1203.  
  1204. VAR     cnt: LONGINT;
  1205.  
  1206. BEGIN
  1207.   IF mjpaData=NIL THEN
  1208.     NEW(mjpaData);
  1209.     FOR cnt:=0 TO 3 DO ol.New(mjpaData.quantTab[cnt],64*SIZE(LONGINT)); END;
  1210.   END;
  1211.   mjpaData.gray:=grayScale;
  1212.   mjpaData.yuvTab:=ys.GenYUVTables();
  1213.   mjpaData.yuvBuf:=ys.AllocMCUBuffers(codec.width,codec.height);
  1214.   mjpaData.limit:=ys.InitLimitTables();
  1215.   mjpaData.cmap:=cmap;
  1216.   SelectMJPAFuncs(mjpaData,(colorReduction & ~ham8) OR grayScale,o.dither);
  1217.   codec.decoder:=DecodeMJPA;
  1218.   codec.special:=mjpaData;
  1219. END SetupMJPA;
  1220. (* \\\ ------------------------------------------------------------------------- *)
  1221.  
  1222. (* /// ---------------------------- "TYPE MSVCData" ---------------------------- *)
  1223. TYPE    MSVCDataPtr=UNTRACED POINTER TO MSVCData;
  1224.         MSVCData=STRUCT
  1225.             gray: BOOLEAN;
  1226.             limit: ys.RangeLimitPtr;
  1227.             cmap: CMapArrPtr;
  1228.         END;
  1229.  
  1230. VAR     msvcData: MSVCDataPtr;
  1231. (* \\\ ------------------------------------------------------------------------- *)
  1232.  
  1233. (* /// ----------------------- "PROCEDURE DecodeMSVC8()" ----------------------- *)
  1234. PROCEDURE DecodeMSVC8 {"_DecodeMSVC8"} (from{8}: e.APTR;
  1235.                                         to{9}: e.APTR;
  1236.                                         width{0}: LONGINT;
  1237.                                         height{1}: LONGINT;
  1238.                                         encSize{2}: LONGINT;
  1239.                                         spec{10}: e.APTR);
  1240.  
  1241. PROCEDURE SetupMSVC8(VAR codec: CodecHeader);
  1242. BEGIN
  1243.   codec.decoder:=DecodeMSVC8;
  1244.   codec.special:=NIL;
  1245. END SetupMSVC8;
  1246. (* \\\ ------------------------------------------------------------------------- *)
  1247.  
  1248. (* /// ---------------------- "PROCEDURE DecodeMSVC16()" ----------------------- *)
  1249. PROCEDURE DecodeMSVC16toRGB {"_DecodeMSVC16toRGB"} (from{8}: e.APTR;
  1250.                                                     to{9}: e.APTR;
  1251.                                                     width{0}: LONGINT;
  1252.                                                     height{1}: LONGINT;
  1253.                                                     encSize{2}: LONGINT;
  1254.                                                     spec{10}: e.APTR);
  1255.  
  1256. PROCEDURE DecodeMSVC16to332 {"_DecodeMSVC16to332"} (from{8}: e.APTR;
  1257.                                                      to{9}: e.APTR;
  1258.                                                      width{0}: LONGINT;
  1259.                                                      height{1}: LONGINT;
  1260.                                                      encSize{2}: LONGINT;
  1261.                                                      spec{10}: e.APTR);
  1262.  
  1263. PROCEDURE DecodeMSVC16to332Dith {"_DecodeMSVC16to332Dith"} (from{8}: e.APTR;
  1264.                                                             to{9}: e.APTR;
  1265.                                                             width{0}: LONGINT;
  1266.                                                             height{1}: LONGINT;
  1267.                                                             encSize{2}: LONGINT;
  1268.                                                             spec{10}: e.APTR);
  1269.  
  1270. PROCEDURE SetupMSVC16(VAR codec: CodecHeader);
  1271. BEGIN
  1272.   IF msvcData=NIL THEN NEW(msvcData); END;
  1273.   msvcData.gray:=grayScale;
  1274.   IF (colorReduction & ~ham8 & ~o.dither) OR grayScale THEN
  1275.     codec.decoder:=DecodeMSVC16to332;
  1276.   ELSE
  1277.     IF o.dither THEN
  1278.       msvcData.limit:=ys.InitLimitTables();
  1279.       msvcData.cmap:=cmap;
  1280.       codec.decoder:=DecodeMSVC16to332Dith;
  1281.     ELSE
  1282.       codec.decoder:=DecodeMSVC16toRGB;
  1283.     END;
  1284.   END;
  1285.   codec.special:=msvcData;
  1286. END SetupMSVC16;
  1287. (* \\\ ------------------------------------------------------------------------- *)
  1288.  
  1289. (* /// --------------------------- "TYPE QTRLEData" ---------------------------- *)
  1290. TYPE    QTRLEDataPtr=UNTRACED POINTER TO QTRLEData;
  1291.         QTRLEData=STRUCT
  1292.             gray: BOOLEAN;
  1293.             limit: ys.RangeLimitPtr;
  1294.             cmap: CMapArrPtr;
  1295.         END;
  1296.  
  1297. VAR     qtrleData: QTRLEDataPtr;
  1298. (* \\\ ------------------------------------------------------------------------- *)
  1299.  
  1300. (* /// ---------------------- "PROCEDURE DecodeQTRLE1()" ----------------------- *)
  1301. PROCEDURE DecodeQTRLE1 {"_DecodeQTRLE1"} (from{8}: e.APTR;
  1302.                                           to{9}: e.APTR;
  1303.                                           width{0}: LONGINT;
  1304.                                           height{1}: LONGINT;
  1305.                                           encSize{2}: LONGINT;
  1306.                                           spec{10}: e.APTR);
  1307.  
  1308. PROCEDURE SetupQTRLE1(VAR codec: CodecHeader);
  1309. BEGIN
  1310.   codec.decoder:=DecodeQTRLE1;
  1311.   codec.special:=NIL;
  1312. END SetupQTRLE1;
  1313. (* \\\ ------------------------------------------------------------------------- *)
  1314.  
  1315. (* /// ---------------------- "PROCEDURE DecodeQTRLE4()" ----------------------- *)
  1316. PROCEDURE DecodeQTRLE4 {"_DecodeQTRLE4"} (from{8}: e.APTR;
  1317.                                           to{9}: e.APTR;
  1318.                                           width{0}: LONGINT;
  1319.                                           height{1}: LONGINT;
  1320.                                           encSize{2}: LONGINT;
  1321.                                           spec{10}: e.APTR);
  1322.  
  1323. PROCEDURE SetupQTRLE4(VAR codec: CodecHeader);
  1324. BEGIN
  1325.   codec.decoder:=DecodeQTRLE4;
  1326.   codec.special:=NIL;
  1327. END SetupQTRLE4;
  1328. (* \\\ ------------------------------------------------------------------------- *)
  1329.  
  1330. (* /// ---------------------- "PROCEDURE DecodeQTRLE8()" ----------------------- *)
  1331. PROCEDURE DecodeQTRLE8 {"_DecodeQTRLE8"} (from{8}: e.APTR;
  1332.                                           to{9}: e.APTR;
  1333.                                           width{0}: LONGINT;
  1334.                                           height{1}: LONGINT;
  1335.                                           encSize{2}: LONGINT;
  1336.                                           spec{10}: e.APTR);
  1337.  
  1338. PROCEDURE SetupQTRLE8(VAR codec: CodecHeader);
  1339. BEGIN
  1340.   codec.decoder:=DecodeQTRLE8;
  1341.   codec.special:=NIL;
  1342. END SetupQTRLE8;
  1343. (* \\\ ------------------------------------------------------------------------- *)
  1344.  
  1345. (* /// ---------------------- "PROCEDURE DecodeQTRLE16()" ---------------------- *)
  1346. PROCEDURE DecodeQTRLE16toRGB {"_DecodeQTRLE16toRGB"} (from{8}: e.APTR;
  1347.                                                       to{9}: e.APTR;
  1348.                                                       width{0}: LONGINT;
  1349.                                                       height{1}: LONGINT;
  1350.                                                       encSize{2}: LONGINT;
  1351.                                                       spec{10}: e.APTR);
  1352.  
  1353. PROCEDURE DecodeQTRLE16to332 {"_DecodeQTRLE16to332"} (from{8}: e.APTR;
  1354.                                                       to{9}: e.APTR;
  1355.                                                       width{0}: LONGINT;
  1356.                                                       height{1}: LONGINT;
  1357.                                                       encSize{2}: LONGINT;
  1358.                                                       spec{10}: e.APTR);
  1359.  
  1360. PROCEDURE DecodeQTRLE16to332Dith {"_DecodeQTRLE16to332Dith"} (from{8}: e.APTR;
  1361.                                                               to{9}: e.APTR;
  1362.                                                               width{0}: LONGINT;
  1363.                                                               height{1}: LONGINT;
  1364.                                                               encSize{2}: LONGINT;
  1365.                                                               spec{10}: e.APTR);
  1366.  
  1367. PROCEDURE SetupQTRLE16(VAR codec: CodecHeader);
  1368. BEGIN
  1369.   IF qtrleData=NIL THEN NEW(qtrleData); END;
  1370.   qtrleData.gray:=grayScale;
  1371.   IF (colorReduction & ~ham8 & ~o.dither) OR grayScale THEN
  1372.     codec.decoder:=DecodeQTRLE16to332;
  1373.   ELSE
  1374.     IF o.dither THEN
  1375.       qtrleData.limit:=ys.InitLimitTables();
  1376.       qtrleData.cmap:=cmap;
  1377.       codec.decoder:=DecodeQTRLE16to332Dith;
  1378.     ELSE
  1379.       codec.decoder:=DecodeQTRLE16toRGB;
  1380.     END;
  1381.   END;
  1382.   codec.special:=qtrleData;
  1383. END SetupQTRLE16;
  1384. (* \\\ ------------------------------------------------------------------------- *)
  1385.  
  1386. (* /// ---------------------- "PROCEDURE DecodeQTRLE24()" ---------------------- *)
  1387. PROCEDURE DecodeQTRLE24toRGB {"_DecodeQTRLE24toRGB"} (from{8}: e.APTR;
  1388.                                                       to{9}: e.APTR;
  1389.                                                       width{0}: LONGINT;
  1390.                                                       height{1}: LONGINT;
  1391.                                                       encSize{2}: LONGINT;
  1392.                                                       spec{10}: e.APTR);
  1393.  
  1394. PROCEDURE DecodeQTRLE24to332 {"_DecodeQTRLE24to332"} (from{8}: e.APTR;
  1395.                                                       to{9}: e.APTR;
  1396.                                                       width{0}: LONGINT;
  1397.                                                       height{1}: LONGINT;
  1398.                                                       encSize{2}: LONGINT;
  1399.                                                       spec{10}: e.APTR);
  1400.  
  1401. PROCEDURE DecodeQTRLE24to332Dith {"_DecodeQTRLE24to332Dith"} (from{8}: e.APTR;
  1402.                                                               to{9}: e.APTR;
  1403.                                                               width{0}: LONGINT;
  1404.                                                               height{1}: LONGINT;
  1405.                                                               encSize{2}: LONGINT;
  1406.                                                               spec{10}: e.APTR);
  1407.  
  1408. PROCEDURE SetupQTRLE24(VAR codec: CodecHeader);
  1409. BEGIN
  1410.   IF qtrleData=NIL THEN NEW(qtrleData); END;
  1411.   qtrleData.gray:=grayScale;
  1412.   IF (colorReduction & ~ham8 & ~o.dither) OR grayScale THEN
  1413.     codec.decoder:=DecodeQTRLE24to332;
  1414.   ELSE
  1415.     IF o.dither THEN
  1416.       qtrleData.limit:=ys.InitLimitTables();
  1417.       qtrleData.cmap:=cmap;
  1418.       codec.decoder:=DecodeQTRLE24to332Dith;
  1419.     ELSE
  1420.       codec.decoder:=DecodeQTRLE24toRGB;
  1421.     END;
  1422.   END;
  1423.   codec.special:=qtrleData;
  1424. END SetupQTRLE24;
  1425. (* \\\ ------------------------------------------------------------------------- *)
  1426.  
  1427. (* /// ---------------------- "PROCEDURE DecodeQTRLE32()" ---------------------- *)
  1428. PROCEDURE DecodeQTRLE32toRGB {"_DecodeQTRLE32toRGB"} (from{8}: e.APTR;
  1429.                                                       to{9}: e.APTR;
  1430.                                                       width{0}: LONGINT;
  1431.                                                       height{1}: LONGINT;
  1432.                                                       encSize{2}: LONGINT;
  1433.                                                       spec{10}: e.APTR);
  1434.  
  1435. PROCEDURE DecodeQTRLE32to332 {"_DecodeQTRLE32to332"} (from{8}: e.APTR;
  1436.                                                       to{9}: e.APTR;
  1437.                                                       width{0}: LONGINT;
  1438.                                                       height{1}: LONGINT;
  1439.                                                       encSize{2}: LONGINT;
  1440.                                                       spec{10}: e.APTR);
  1441.  
  1442. PROCEDURE DecodeQTRLE32to332Dith {"_DecodeQTRLE32to332Dith"} (from{8}: e.APTR;
  1443.                                                               to{9}: e.APTR;
  1444.                                                               width{0}: LONGINT;
  1445.                                                               height{1}: LONGINT;
  1446.                                                               encSize{2}: LONGINT;
  1447.                                                               spec{10}: e.APTR);
  1448.  
  1449. PROCEDURE SetupQTRLE32(VAR codec: CodecHeader);
  1450. BEGIN
  1451.   IF qtrleData=NIL THEN NEW(qtrleData); END;
  1452.   qtrleData.gray:=grayScale;
  1453.   IF (colorReduction & ~ham8 & ~o.dither) OR grayScale THEN
  1454.     codec.decoder:=DecodeQTRLE32to332;
  1455.   ELSE
  1456.     IF o.dither THEN
  1457.       qtrleData.limit:=ys.InitLimitTables();
  1458.       qtrleData.cmap:=cmap;
  1459.       codec.decoder:=DecodeQTRLE32to332Dith;
  1460.     ELSE
  1461.       codec.decoder:=DecodeQTRLE32toRGB;
  1462.     END;
  1463.   END;
  1464.   codec.special:=qtrleData;
  1465. END SetupQTRLE32;
  1466. (* \\\ ------------------------------------------------------------------------- *)
  1467.  
  1468. (* /// ---------------------------- "TYPE RAWData" ----------------------------- *)
  1469. TYPE    RAWDataPtr=UNTRACED POINTER TO RAWData;
  1470.         RAWData=STRUCT
  1471.             gray: BOOLEAN;
  1472.             limit: ys.RangeLimitPtr;
  1473.             cmap: CMapArrPtr;
  1474.         END;
  1475.  
  1476. VAR     rawData: RAWDataPtr;
  1477. (* \\\ ------------------------------------------------------------------------- *)
  1478.  
  1479. (* /// ----------------------- "PROCEDURE DecodeRAW1()" ------------------------ *)
  1480. PROCEDURE DecodeRAW1 {"_DecodeRAW1"} (from{8}: e.APTR;
  1481.                                       to{9}: e.APTR;
  1482.                                       width{0}: LONGINT;
  1483.                                       height{1}: LONGINT;
  1484.                                       encSize{2}: LONGINT;
  1485.                                       spec{10}: e.APTR);
  1486.  
  1487. PROCEDURE SetupRAW1(VAR codec: CodecHeader);
  1488. BEGIN
  1489.   codec.decoder:=DecodeRAW1;
  1490.   codec.special:=NIL;
  1491. END SetupRAW1;
  1492. (* \\\ ------------------------------------------------------------------------- *)
  1493.  
  1494. (* /// ----------------------- "PROCEDURE DecodeRAW4()" ------------------------ *)
  1495. PROCEDURE DecodeRAW4 {"_DecodeRAW4"} (from{8}: e.APTR;
  1496.                                       to{9}: e.APTR;
  1497.                                       width{0}: LONGINT;
  1498.                                       height{1}: LONGINT;
  1499.                                       encSize{2}: LONGINT;
  1500.                                       spec{10}: e.APTR);
  1501.  
  1502. PROCEDURE SetupRAW4(VAR codec: CodecHeader);
  1503. BEGIN
  1504.   codec.decoder:=DecodeRAW4;
  1505.   codec.special:=NIL;
  1506. END SetupRAW4;
  1507. (* \\\ ------------------------------------------------------------------------- *)
  1508.  
  1509. (* /// ----------------------- "PROCEDURE DecodeRAW8()" ------------------------ *)
  1510. PROCEDURE DecodeRAW8 (from{8}: e.APTR;
  1511.                       to{9}: e.APTR;
  1512.                       width{0}: LONGINT;
  1513.                       height{1}: LONGINT;
  1514.                       encSize{2}: LONGINT;
  1515.                       spec{10}: e.APTR);
  1516. BEGIN
  1517.   e.CopyMemQuickAPTR(from,to,frameSize);
  1518. END DecodeRAW8;
  1519.  
  1520. PROCEDURE SetupRAW8(VAR codec: CodecHeader);
  1521. BEGIN
  1522.   codec.decoder:=DecodeRAW8;
  1523.   codec.special:=NIL;
  1524. END SetupRAW8;
  1525. (* \\\ ------------------------------------------------------------------------- *)
  1526.  
  1527. (* /// ----------------------- "PROCEDURE DecodeRAW16()" ----------------------- *)
  1528. PROCEDURE DecodeRAW16toRGB {"_DecodeRAW16toRGB"} (from{8}: e.APTR;
  1529.                                                   to{9}: e.APTR;
  1530.                                                   width{0}: LONGINT;
  1531.                                                   height{1}: LONGINT;
  1532.                                                   encSize{2}: LONGINT;
  1533.                                                   spec{10}: e.APTR);
  1534.  
  1535. PROCEDURE DecodeRAW16to332 {"_DecodeRAW16to332"} (from{8}: e.APTR;
  1536.                                                   to{9}: e.APTR;
  1537.                                                   width{0}: LONGINT;
  1538.                                                   height{1}: LONGINT;
  1539.                                                   encSize{2}: LONGINT;
  1540.                                                   spec{10}: e.APTR);
  1541.  
  1542. PROCEDURE DecodeRAW16to332Dith {"_DecodeRAW16to332Dith"} (from{8}: e.APTR;
  1543.                                                           to{9}: e.APTR;
  1544.                                                           width{0}: LONGINT;
  1545.                                                           height{1}: LONGINT;
  1546.                                                           encSize{2}: LONGINT;
  1547.                                                           spec{10}: e.APTR);
  1548.  
  1549. PROCEDURE SetupRAW16(VAR codec: CodecHeader);
  1550. BEGIN
  1551.   IF rawData=NIL THEN NEW(rawData); END;
  1552.   rawData.gray:=grayScale;
  1553.   IF (colorReduction & ~ham8 & ~o.dither) OR grayScale THEN
  1554.     codec.decoder:=DecodeRAW16to332;
  1555.   ELSE
  1556.     IF o.dither THEN
  1557.       rawData.limit:=ys.InitLimitTables();
  1558.       rawData.cmap:=cmap;
  1559.       codec.decoder:=DecodeRAW16to332Dith;
  1560.     ELSE
  1561.       codec.decoder:=DecodeRAW16toRGB;
  1562.     END;
  1563.   END;
  1564.   codec.special:=rawData;
  1565. END SetupRAW16;
  1566. (* \\\ ------------------------------------------------------------------------- *)
  1567.  
  1568. (* /// ----------------------- "PROCEDURE DecodeRAW24()" ----------------------- *)
  1569. PROCEDURE DecodeRAW24toRGB (from{8}: e.APTR;
  1570.                             to{9}: e.APTR;
  1571.                             width{0}: LONGINT;
  1572.                             height{1}: LONGINT;
  1573.                             encSize{2}: LONGINT;
  1574.                             spec{10}: e.APTR);
  1575. BEGIN
  1576.   e.CopyMemQuickAPTR(from,to,frameSize);
  1577. END DecodeRAW24toRGB;
  1578.  
  1579. PROCEDURE DecodeRAW24to332 {"_DecodeRAW24to332"} (from{8}: e.APTR;
  1580.                                                   to{9}: e.APTR;
  1581.                                                   width{0}: LONGINT;
  1582.                                                   height{1}: LONGINT;
  1583.                                                   encSize{2}: LONGINT;
  1584.                                                   spec{10}: e.APTR);
  1585.  
  1586. PROCEDURE DecodeRAW24to332Dith {"_DecodeRAW24to332Dith"} (from{8}: e.APTR;
  1587.                                                           to{9}: e.APTR;
  1588.                                                           width{0}: LONGINT;
  1589.                                                           height{1}: LONGINT;
  1590.                                                           encSize{2}: LONGINT;
  1591.                                                           spec{10}: e.APTR);
  1592.  
  1593. PROCEDURE SetupRAW24(VAR codec: CodecHeader);
  1594. BEGIN
  1595.   IF rawData=NIL THEN NEW(rawData); END;
  1596.   rawData.gray:=grayScale;
  1597.   IF (colorReduction & ~ham8 & ~o.dither) OR grayScale THEN
  1598.     codec.decoder:=DecodeRAW24to332;
  1599.   ELSE
  1600.     IF o.dither THEN
  1601.       rawData.limit:=ys.InitLimitTables();
  1602.       rawData.cmap:=cmap;
  1603.       codec.decoder:=DecodeRAW24to332Dith;
  1604.     ELSE
  1605.       codec.decoder:=DecodeRAW24toRGB;
  1606.     END;
  1607.   END;
  1608.   codec.special:=rawData;
  1609. END SetupRAW24;
  1610. (* \\\ ------------------------------------------------------------------------- *)
  1611.  
  1612. (* /// ----------------------- "PROCEDURE DecodeRAW32()" ----------------------- *)
  1613. PROCEDURE DecodeRAW32toRGB {"_DecodeRAW32toRGB"} (from{8}: e.APTR;
  1614.                                                   to{9}: e.APTR;
  1615.                                                   width{0}: LONGINT;
  1616.                                                   height{1}: LONGINT;
  1617.                                                   encSize{2}: LONGINT;
  1618.                                                   spec{10}: e.APTR);
  1619.  
  1620. PROCEDURE DecodeRAW32to332 {"_DecodeRAW32to332"} (from{8}: e.APTR;
  1621.                                                   to{9}: e.APTR;
  1622.                                                   width{0}: LONGINT;
  1623.                                                   height{1}: LONGINT;
  1624.                                                   encSize{2}: LONGINT;
  1625.                                                   spec{10}: e.APTR);
  1626.  
  1627. PROCEDURE DecodeRAW32to332Dith {"_DecodeRAW32to332Dith"} (from{8}: e.APTR;
  1628.                                                           to{9}: e.APTR;
  1629.                                                           width{0}: LONGINT;
  1630.                                                           height{1}: LONGINT;
  1631.                                                           encSize{2}: LONGINT;
  1632.                                                           spec{10}: e.APTR);
  1633.  
  1634. PROCEDURE SetupRAW32(VAR codec: CodecHeader);
  1635. BEGIN
  1636.   IF rawData=NIL THEN NEW(rawData); END;
  1637.   rawData.gray:=grayScale;
  1638.   IF (colorReduction & ~ham8 & ~o.dither) OR grayScale THEN
  1639.     codec.decoder:=DecodeRAW32to332;
  1640.   ELSE
  1641.     IF o.dither THEN
  1642.       rawData.limit:=ys.InitLimitTables();
  1643.       rawData.cmap:=cmap;
  1644.       codec.decoder:=DecodeRAW32to332Dith;
  1645.     ELSE
  1646.       codec.decoder:=DecodeRAW32toRGB;
  1647.     END;
  1648.   END;
  1649.   codec.special:=rawData;
  1650. END SetupRAW32;
  1651. (* \\\ ------------------------------------------------------------------------- *)
  1652.  
  1653. (* /// ---------------------------- "TYPE RPZAData" ---------------------------- *)
  1654. TYPE    RPZADataPtr=UNTRACED POINTER TO RPZAData;
  1655.         RPZAData=STRUCT
  1656.             gray: BOOLEAN;
  1657.             limit: ys.RangeLimitPtr;
  1658.             cmap: CMapArrPtr;
  1659.         END;
  1660.  
  1661. VAR     rpzaData: RPZADataPtr;
  1662. (* \\\ ------------------------------------------------------------------------- *)
  1663.  
  1664. (* /// ----------------------- "PROCEDURE DecodeRPZA()" ------------------------ *)
  1665. PROCEDURE DecodeRPZAtoRGB {"_DecodeRPZAtoRGB"} (from{8}: e.APTR;
  1666.                                                 to{9}: e.APTR;
  1667.                                                 width{0}: LONGINT;
  1668.                                                 height{1}: LONGINT;
  1669.                                                 encSize{2}: LONGINT;
  1670.                                                 spec{10}: e.APTR);
  1671.  
  1672. PROCEDURE DecodeRPZAto332 {"_DecodeRPZAto332"} (from{8}: e.APTR;
  1673.                                                 to{9}: e.APTR;
  1674.                                                 width{0}: LONGINT;
  1675.                                                 height{1}: LONGINT;
  1676.                                                 encSize{2}: LONGINT;
  1677.                                                 spec{10}: e.APTR);
  1678.  
  1679. PROCEDURE DecodeRPZAto332Dith {"_DecodeRPZAto332Dith"} (from{8}: e.APTR;
  1680.                                                         to{9}: e.APTR;
  1681.                                                         width{0}: LONGINT;
  1682.                                                         height{1}: LONGINT;
  1683.                                                         encSize{2}: LONGINT;
  1684.                                                         spec{10}: e.APTR);
  1685.  
  1686. PROCEDURE SetupRPZA(VAR codec: CodecHeader);
  1687. BEGIN
  1688.   IF rpzaData=NIL THEN NEW(rpzaData); END;
  1689.   rpzaData.gray:=grayScale;
  1690.   IF (colorReduction & ~ham8) OR grayScale OR o.dither THEN
  1691.     IF o.dither THEN
  1692.       rpzaData.limit:=ys.InitLimitTables();
  1693.       rpzaData.cmap:=cmap;
  1694.       codec.decoder:=DecodeRPZAto332Dith;
  1695.     ELSE
  1696.       codec.decoder:=DecodeRPZAto332;
  1697.     END;
  1698.   ELSE
  1699.     codec.decoder:=DecodeRPZAtoRGB;
  1700.   END;
  1701.   codec.special:=rpzaData;
  1702. END SetupRPZA;
  1703. (* \\\ ------------------------------------------------------------------------- *)
  1704.  
  1705. (* /// ---------------------------- "TYPE SMCData" ----------------------------- *)
  1706. CONST   smcMaxCnt=256;
  1707.  
  1708. TYPE    SMCDataPtr=UNTRACED POINTER TO SMCData;
  1709.         SMCData=STRUCT
  1710.             smc8: ARRAY 2*smcMaxCnt OF LONGINT;
  1711.             smcA: ARRAY 4*smcMaxCnt OF LONGINT;
  1712.             smcC: ARRAY 8*smcMaxCnt OF LONGINT;
  1713.         END;
  1714.  
  1715. VAR     smcData: SMCDataPtr;
  1716. (* \\\ ------------------------------------------------------------------------- *)
  1717.  
  1718. (* /// ------------------------ "PROCEDURE DecodeSMC()" ------------------------ *)
  1719. PROCEDURE DecodeSMC {"_DecodeSMC"} (from{8}: e.APTR;
  1720.                                     to{9}: e.APTR;
  1721.                                     width{0}: LONGINT;
  1722.                                     height{1}: LONGINT;
  1723.                                     encSize{2}: LONGINT;
  1724.                                     spec{10}: e.APTR);
  1725.  
  1726. PROCEDURE SetupSMC(VAR codec: CodecHeader);
  1727. BEGIN
  1728.   IF smcData=NIL THEN NEW(smcData); END;
  1729.   codec.decoder:=DecodeSMC;
  1730.   codec.special:=smcData;
  1731. END SetupSMC;
  1732. (* \\\ ------------------------------------------------------------------------- *)
  1733.  
  1734. (* /// ---------------------------- "TYPE YUV2Data" ---------------------------- *)
  1735. TYPE    YUV2DataPtr=UNTRACED POINTER TO YUV2Data;
  1736.         YUV2Data=STRUCT
  1737.             gray: BOOLEAN;
  1738.             yuvTab: ys.YUVTablePtr;
  1739.             yuvBuf: ys.YUVBufferPtr;
  1740.             limit: ys.RangeLimitPtr;
  1741.             cmap: CMapArrPtr;
  1742.         END;
  1743.  
  1744. VAR     yuv2Data: YUV2DataPtr;
  1745. (* \\\ ------------------------------------------------------------------------- *)
  1746.  
  1747. (* /// ----------------------- "PROCEDURE DecodeYUV2()" ------------------------ *)
  1748. PROCEDURE DecodeYUV2 {"_DecodeYUV2A"} (from{8}: e.APTR;
  1749.                                        to{9}: e.APTR;
  1750.                                        width{0}: LONGINT;
  1751.                                        height{1}: LONGINT;
  1752.                                        encSize{2}: LONGINT;
  1753.                                        spec{10}: e.APTR);
  1754.  
  1755. PROCEDURE SelectYUV2Funcs {"_SelectYUV2Funcs"} (spec{8}: YUV2DataPtr;
  1756.                                                 reduce{0}: BOOLEAN;
  1757.                                                 dither{1}: BOOLEAN);
  1758.  
  1759. PROCEDURE SetupYUV2(VAR codec: CodecHeader);
  1760. BEGIN
  1761.   IF yuv2Data=NIL THEN NEW(yuv2Data); END;
  1762.   yuv2Data.gray:=grayScale;
  1763.   yuv2Data.yuvTab:=ys.GenYUVTables();
  1764.   yuv2Data.yuvBuf:=ys.AllocMCUBuffers(codec.width,codec.height);
  1765.   yuv2Data.limit:=ys.InitLimitTables();
  1766.   yuv2Data.cmap:=cmap;
  1767.   SelectYUV2Funcs(yuv2Data,(colorReduction & ~ham8) OR grayScale,o.dither);
  1768.   codec.decoder:=DecodeYUV2;
  1769.   codec.special:=yuv2Data;
  1770. END SetupYUV2;
  1771. (* \\\ ------------------------------------------------------------------------- *)
  1772.  
  1773. (* /// ---------------------------- "TYPE YUV9Data" ---------------------------- *)
  1774. TYPE    YUV9DataPtr=UNTRACED POINTER TO YUV9Data;
  1775.         YUV9Data=STRUCT
  1776.             gray: BOOLEAN;
  1777.             yuvTab: ys.YUVTablePtr;
  1778.             limit: ys.RangeLimitPtr;
  1779.             cmap: CMapArrPtr;
  1780.         END;
  1781.  
  1782. VAR     yuv9Data: YUV9DataPtr;
  1783. (* \\\ ------------------------------------------------------------------------- *)
  1784.  
  1785. (* /// ----------------------- "PROCEDURE DecodeYUV9()" ------------------------ *)
  1786. PROCEDURE DecodeYUV9 {"_DecodeYUV9"} (from{8}: e.APTR;
  1787.                                       to{9}: e.APTR;
  1788.                                       width{0}: LONGINT;
  1789.                                       height{1}: LONGINT;
  1790.                                       encSize{2}: LONGINT;
  1791.                                       spec{10}: e.APTR);
  1792.  
  1793. PROCEDURE SelectYUV9Funcs {"_SelectYUV9Funcs"} (spec{8}: YUV9DataPtr;
  1794.                                                 reduce{0}: BOOLEAN;
  1795.                                                 dither{1}: BOOLEAN);
  1796.  
  1797. PROCEDURE SetupYUV9(VAR codec: CodecHeader);
  1798. BEGIN
  1799.   IF yuv9Data=NIL THEN NEW(yuv9Data); END;
  1800.   yuv9Data.gray:=grayScale;
  1801.   yuv9Data.yuvTab:=ys.GenYUVTables();
  1802.   yuv9Data.limit:=ys.InitLimitTables();
  1803.   yuv9Data.cmap:=cmap;
  1804.   SelectYUV9Funcs(yuv9Data,(colorReduction & ~ham8) OR grayScale,o.dither);
  1805.   codec.decoder:=DecodeYUV9;
  1806.   codec.special:=yuv9Data;
  1807. END SetupYUV9;
  1808. (* \\\ ------------------------------------------------------------------------- *)
  1809.  
  1810. (* /// ----------------------- "PROCEDURE CodecQuery()" ------------------------ *)
  1811. PROCEDURE CodecQuery * (VAR codec: CodecHeader): LONGINT;
  1812.  
  1813. VAR     ret: LONGINT;
  1814.  
  1815. BEGIN
  1816.   ret:=codecSupported;
  1817.   IF codec.depth>32 THEN DEC(codec.depth,32); END;
  1818.   CASE codec.compression OF
  1819.   | idcvid,
  1820.     idCVID:
  1821.       codec.compression:=idCVID;
  1822.       codec.description:="Radius Cinepak";
  1823.       codec.width:=i2m.Round(codec.width,4);
  1824.       codec.height:=i2m.Round(codec.height,4);
  1825.       IF (codec.depth=8) OR (codec.depth=16) OR (codec.depth=24) OR (codec.depth=32) THEN
  1826.         SetupCVID(codec);
  1827.       ELSE
  1828.         ret:=codecUnsupported;
  1829.       END;
  1830.   | idjpeg:
  1831.       codec.description:="JFIF JPEG";
  1832.       codec.width:=i2m.Round(codec.width,4);
  1833.       codec.height:=i2m.Round(codec.height,2);
  1834.       IF (codec.depth=8) OR (codec.depth=24) THEN
  1835.         SetupJPEG(codec);
  1836.       ELSE
  1837.         ret:=codecUnsupported;
  1838.       END;
  1839.   | idkpcd,
  1840.     idKPCD:
  1841.       codec.compression:=idKPCD;
  1842.       codec.description:="Kodak Photo CD";
  1843.       codec.width:=i2m.Round(codec.width,4);
  1844.       IF (codec.depth=16) OR (codec.depth=24) OR (codec.depth=32) THEN
  1845.         SetupKPCD(codec);
  1846.       ELSE
  1847.         ret:=codecUnsupported;
  1848.       END;
  1849.   | idmjpa:
  1850.       codec.description:="Motion JPEG (type A)";
  1851.       codec.width:=i2m.Round(codec.width,4);
  1852.       codec.height:=i2m.Round(codec.height DIV 2,2); (* es müssen alle Zeilen doppelt angezeigt werden, aber die Höhe wurde als doppelte Höhe gespeichert *)
  1853.       IF (codec.depth=16) OR (codec.depth=24) OR (codec.depth=32) THEN
  1854.         SetupMJPA(codec);
  1855.       ELSE
  1856.         ret:=codecUnsupported;
  1857.       END;
  1858.   | idmsvc,
  1859.     idMSVC,
  1860.     idcram,
  1861.     idCRAM:
  1862.       codec.compression:=idMSVC;
  1863.       codec.description:="Microsoft Video 1";
  1864.       codec.width:=i2m.Round(codec.width,4);
  1865.       codec.height:=i2m.Round(codec.height,4);
  1866.       IF codec.depth=8 THEN
  1867.         SetupMSVC8(codec);
  1868.       ELSIF codec.depth=16 THEN
  1869.         SetupMSVC16(codec);
  1870.       ELSE
  1871.         ret:=codecUnsupported;
  1872.       END;
  1873.   | idraw:
  1874.       codec.description:="Apple Uncompressed";
  1875.       IF codec.depth=1 THEN
  1876.         SetupRAW1(codec);
  1877.       ELSIF codec.depth=4 THEN
  1878.         SetupRAW4(codec);
  1879.       ELSIF codec.depth=8 THEN
  1880.         SetupRAW8(codec);
  1881.       ELSIF codec.depth=16 THEN
  1882.         SetupRAW16(codec);
  1883.       ELSIF codec.depth=24 THEN
  1884.         SetupRAW24(codec);
  1885.       ELSIF codec.depth=32 THEN
  1886.         SetupRAW32(codec);
  1887.       ELSE
  1888.         ret:=codecUnsupported;
  1889.       END;
  1890.   | idrle:
  1891.       codec.description:="Apple Animation (RLE)";
  1892.       IF codec.depth=1 THEN
  1893.         codec.width:=i2m.Round(codec.width,16);
  1894.         SetupQTRLE1(codec);
  1895.       ELSIF codec.depth=4 THEN
  1896.         codec.width:=i2m.Round(codec.width,8);
  1897.         SetupQTRLE4(codec);
  1898.       ELSIF codec.depth=8 THEN
  1899.         codec.width:=i2m.Round(codec.width,4);
  1900.         SetupQTRLE8(codec);
  1901.       ELSIF codec.depth=16 THEN
  1902.         SetupQTRLE16(codec);
  1903.       ELSIF codec.depth=24 THEN
  1904.         SetupQTRLE24(codec);
  1905.       ELSIF codec.depth=32 THEN
  1906.         SetupQTRLE32(codec);
  1907.       ELSE
  1908.         ret:=codecUnsupported;
  1909.       END;
  1910.   | idrpza,
  1911.     idazpr:
  1912.       codec.compression:=idrpza;
  1913.       codec.description:="Apple Video (RPZA)";
  1914.       codec.width:=i2m.Round(codec.width,4);
  1915.       codec.height:=i2m.Round(codec.height,4);
  1916.       IF codec.depth=16 THEN
  1917.         SetupRPZA(codec);
  1918.       ELSE
  1919.         ret:=codecUnsupported;
  1920.       END;
  1921.   | idsmc:
  1922.       codec.description:="Apple Graphics (SMC)";
  1923.       codec.width:=i2m.Round(codec.width,4);
  1924.       codec.height:=i2m.Round(codec.height,4);
  1925.       IF codec.depth=8 THEN
  1926.         SetupSMC(codec);
  1927.       ELSE
  1928.         ret:=codecUnsupported;
  1929.       END;
  1930.   | idyuv2,
  1931.     idYUV2,
  1932.     id2vuy,
  1933.     id2VUY:
  1934.       codec.compression:=idYUV2;
  1935.       codec.description:="Component Video (YUV2)";
  1936.       codec.width:=i2m.Round(codec.width,2);
  1937.       codec.height:=i2m.Round(codec.height,2);
  1938.       IF (codec.depth=16) OR (codec.depth=24) OR (codec.depth=32) THEN
  1939.         SetupYUV2(codec);
  1940.       ELSE
  1941.         ret:=codecUnsupported;
  1942.       END;
  1943.   | idYUV9,
  1944.     idYVU9,
  1945.     id9VUY,
  1946.     id9UVY:
  1947.       codec.compression:=idYUV9;
  1948.       codec.description:="Intel Raw (YUV9)";
  1949.       codec.width:=i2m.Round(codec.width,4);
  1950.       codec.height:=i2m.Round(codec.height,4);
  1951.       IF (codec.depth=16) OR (codec.depth=24) OR (codec.depth=32) THEN
  1952.         SetupYUV9(codec);
  1953.       ELSE
  1954.         ret:=codecUnsupported;
  1955.       END;
  1956.   | idrt21,
  1957.     idRT21:
  1958.       codec.compression:=idRT21;
  1959.       codec.description:="Intel Indeo R2.1";
  1960.       ret:=codecUnsupported;
  1961.   | idiv31,
  1962.     idIV31:
  1963.       codec.compression:=idIV31;
  1964.       codec.description:="Intel Indeo R3.1";
  1965.       ret:=codecUnsupported;
  1966.   | idiv32,
  1967.     idIV32:
  1968.       codec.compression:=idIV32;
  1969.       codec.description:="Intel Indeo R3.2";
  1970.       ret:=codecUnsupported;
  1971.   | idiv41,
  1972.     idIV41:
  1973.       codec.compression:=idIV41;
  1974.       codec.description:="Intel Indeo R4.1";
  1975.       ret:=codecUnsupported;
  1976.   | idiv50,
  1977.     idIV50:
  1978.       codec.compression:=idIV50;
  1979.       codec.description:="Intel Indeo R5.0";
  1980.       ret:=codecUnsupported;
  1981.   | idcyuv,
  1982.     idCYUV:
  1983.       codec.compression:=idCYUV;
  1984.       codec.description:="Creative Technology (CYUV)";
  1985.       ret:=codecUnsupported;
  1986.   | idmjpb:
  1987.       codec.description:="Motion JPEG (type B)";
  1988.       ret:=codecUnsupported;
  1989.   ELSE
  1990.     ret:=codecUnknown;
  1991.   END;
  1992.   RETURN ret;
  1993. END CodecQuery;
  1994. (* \\\ ------------------------------------------------------------------------- *)
  1995.  
  1996. (* /// ------------------------- "PROCEDURE FastC2P()" ------------------------- *)
  1997. PROCEDURE FastC2P4 {"_FastC2P4"} (chunky{8}: e.APTR;
  1998.                                   bitmap{9}: gfx.BitMapPtr;
  1999.                                   realWidth{1}: LONGINT);
  2000.  
  2001. PROCEDURE FastC2P8 {"_FastC2P8"} (chunky{8}: e.APTR;
  2002.                                   bitmap{9}: gfx.BitMapPtr;
  2003.                                   realWidth{1}: LONGINT);
  2004. (* \\\ ------------------------------------------------------------------------- *)
  2005.  
  2006. (* /// ------------------------ "PROCEDURE RGBtoHAM8()" ------------------------ *)
  2007. PROCEDURE RGBtoHAM8 {"_RGBtoHAM8"} (rgb{8}: e.APTR;
  2008.                                     ham8{9}: e.APTR;
  2009.                                     width{0}: LONGINT;
  2010.                                     height{1}: LONGINT);
  2011. (* \\\ ------------------------------------------------------------------------- *)
  2012.  
  2013. (* /// ---------------------- "PROCEDURE DisplayFrame()" ----------------------- *)
  2014. PROCEDURE DisplayFrameDummy();
  2015. BEGIN
  2016. END DisplayFrameDummy;
  2017.  
  2018. PROCEDURE DisplayFrameAGA();
  2019. BEGIN
  2020.   gfx.WaitBlit();
  2021.   IF ham8 THEN
  2022.     RGBtoHAM8(videoDataDec,ham8Buffer,calcWidth,calcHeight);
  2023.     fastc2pProc(ham8Buffer,tmpBM,calcWidth);
  2024.   ELSE
  2025.     fastc2pProc(videoDataDec,tmpBM,calcWidth);
  2026.   END;
  2027.   gfx.BltBitMapRastPort(tmpBM,0,0,rp,leftOff,topOff,animWidth,animHeight,y.VAL(y.BYTE,0C0H));
  2028. END DisplayFrameAGA;
  2029.  
  2030. PROCEDURE DisplayFrameCyberGfx();
  2031.  
  2032. VAR     width: INTEGER;
  2033.         height: INTEGER;
  2034.  
  2035. BEGIN
  2036.   IF pubScreen THEN
  2037.     IF animDepth>8 THEN
  2038.       width:=window.width-(window.borderLeft+window.borderRight);
  2039.       height:=window.height-(window.borderTop+window.borderBottom);
  2040.       IF (width#animWidth) OR (height#animHeight) THEN
  2041.         y.SETREG(0,cgfx.ScalePixelArray(videoDataDec,animWidth,animHeight,dispModulo,rp,leftOff,topOff,width,height,colorType));
  2042.       ELSE
  2043.         y.SETREG(0,cgfx.WritePixelArray(videoDataDec,0,0,dispModulo,rp,leftOff,topOff,animWidth,animHeight,colorType));
  2044.       END;
  2045.     ELSE
  2046.       y.SETREG(0,cgfx.WriteLUTPixelArray(videoDataDec,0,0,dispModulo,rp,cmap,leftOff,topOff,animWidth,animHeight,cgfx.fmtXRGB8));
  2047.     END;
  2048.   ELSE
  2049.     y.SETREG(0,cgfx.WritePixelArray(videoDataDec,0,0,dispModulo,rp,leftOff,topOff,animWidth,animHeight,colorType));
  2050.   END;
  2051. END DisplayFrameCyberGfx;
  2052. (* \\\ ------------------------------------------------------------------------- *)
  2053.  
  2054. (* /// ---------------------- "PROCEDURE InitVideoFile()" ---------------------- *)
  2055. PROCEDURE InitVideoFile * (name: ARRAY OF CHAR): BOOLEAN; (* $CopyArrays- *)
  2056. BEGIN
  2057.   RETURN io.Open(videoFile,name,o.bufferSize,FALSE);
  2058. END InitVideoFile;
  2059. (* \\\ ------------------------------------------------------------------------- *)
  2060.  
  2061. (* /// ----------------------- "PROCEDURE DecodeFrame()" ----------------------- *)
  2062. PROCEDURE DecodeFrame * (offset: LONGINT;
  2063.                          size: LONGINT;
  2064.                          codec: LONGINT);
  2065. VAR fh: d.FileHandlePtr;
  2066. BEGIN
  2067.   io.SeekTo(videoFile,offset);
  2068.   io.Read(videoFile,videoData,size);
  2069.   IF codec#currentCodec THEN
  2070.     decoderProc:=codecs[codec].decoder;
  2071.     decoderSpec:=codecs[codec].special;
  2072. (*
  2073.     calcWidth:=codecs[codec].width;
  2074.     calcHeight:=codecs[codec].height;
  2075. *)
  2076.     currentCodec:=codec;
  2077.   END;
  2078.   decoderProc(videoData,videoDataDec,calcWidth,calcHeight,size,decoderSpec);
  2079.   displayProc();
  2080. (*
  2081.   fh:=d.Open("sd0:x",d.newFile);
  2082.   y.SETREG(0,d.Write(fh,videoData^,size));
  2083.   d.OldClose(fh);
  2084. *)
  2085. END DecodeFrame;
  2086. (* \\\ ------------------------------------------------------------------------- *)
  2087.  
  2088. (* /// ---------------------- "PROCEDURE AllocBuffers()" ----------------------- *)
  2089. PROCEDURE AllocBuffers * (): BOOLEAN;
  2090.  
  2091. VAR     track: g.TrackPtr;
  2092.         desc: g.VideoDescriptionPtr;
  2093.         codec: CodecHeader;
  2094.         cnt: LONGINT;
  2095.         cur: LONGINT;
  2096.         ret: BOOLEAN;
  2097.         size: LONGINT;
  2098.         minDepth: LONGINT;
  2099.         maxDepth: LONGINT;
  2100.  
  2101. BEGIN
  2102.   colorReduction:=g.agaOnly OR (g.gfxBoth & o.aga) OR (g.cgfxOnly & o.aga);
  2103.   ham8:=o.ham8;
  2104.   grayScale:=o.grayScale;
  2105.   ret:=TRUE;
  2106.   track:=g.animInfo.videoTracks.head;
  2107.   (* $RangeChk- *)
  2108.   animWidth:=SHORT(fp.FP32toINT(track.head.width));
  2109.   animHeight:=SHORT(fp.FP32toINT(track.head.height));
  2110.   calcWidth:=animWidth;
  2111.   calcHeight:=animHeight;
  2112.   (* $RangeChk= *)
  2113.   DetermineDepth();
  2114.   minDepth:=MAX(LONGINT);
  2115.   maxDepth:=MIN(LONGINT);
  2116.   DISPOSE(codecs);
  2117.   IF es.ListEmpty(g.animInfo.videoTracks) THEN RETURN FALSE; END;
  2118.  
  2119.   ol.New(codecs,cu.CalcDescEntries(g.animInfo.videoTracks)*SIZE(CodecHeader));
  2120.   cur:=0;
  2121.   WHILE track.node.succ#NIL DO
  2122.     FOR cnt:=0 TO track.descriptionEntries-1 DO
  2123.       desc:=y.VAL(g.VideoDescriptionPtr,track.descriptions[cnt]);
  2124.       InitColorMap(desc);
  2125.       codec.compression:=desc.head.dataFormat;
  2126.       codec.width:=desc.width;
  2127.       codec.height:=desc.height;
  2128.       codec.depth:=desc.depth;
  2129.       CASE CodecQuery(codec) OF
  2130.       | codecUnsupported:
  2131.           d.PrintF("  Unsupported video encoding: %s [",y.ADR(codec.description)); cu.PrintFCC(codec.compression); d.PrintF("], depth %ld\n",desc.depth);
  2132.           ret:=FALSE;
  2133.           IF (codec.compression=idRT21) OR (codec.compression=idIV31) OR (codec.compression=idIV32) OR (codec.compression=idIV41) OR (codec.compression=idIV50) THEN d.PrintF("Please consult the manual/FAQ for information about Intel Indeo\n"); END;
  2134.       | codecUnknown:
  2135.           d.PrintF("  Unknown video encoding: "); cu.PrintFCC(codec.compression); d.PrintF(", depth %ld\n",desc.depth);
  2136.           ret:=FALSE;
  2137.       ELSE
  2138.         minDepth:=mu.min(minDepth,codec.depth);
  2139.         maxDepth:=mu.max(maxDepth,codec.depth);
  2140.         calcWidth:=mu.max(calcWidth,codec.width);
  2141.         calcHeight:=mu.max(calcHeight,codec.height);
  2142.         IF ~o.quiet THEN
  2143.           d.PrintF("  Video: %s, %ld bit, %ld×%ld\n",y.ADR(codec.description),
  2144.                                                      codec.depth,
  2145.                                                      animWidth,
  2146.                                                      animHeight);
  2147.         END;
  2148.       END;
  2149.       codecs[cur]:=codec;
  2150.       INC(cur);
  2151.     END;
  2152.     track:=track.node.succ;
  2153.   END;
  2154.  
  2155.   IF ret THEN
  2156.     DISPOSE(videoData);
  2157.     DISPOSE(ham8Buffer);
  2158.     DISPOSE(videoDataDec);
  2159.     size:=i2m.Round(cu.CalcMaxSize(g.animInfo.videoTracks,TRUE),e.blockSize);
  2160.     frameSize:=i2m.Round(calcWidth*calcHeight,4); (* ungerade Größen ergeben Mungwall-Hits *)
  2161.     dispModulo:=i.LongToUInt(calcWidth);
  2162.     IF animDepth<=8 THEN
  2163.       ham8:=FALSE;
  2164.       colorType:=cgfx.rectFmtLUT8;
  2165.     ELSE
  2166.       IF ham8 THEN ol.New(ham8Buffer,mu.max(size,frameSize)); END;
  2167.       IF grayScale THEN
  2168.         colorType:=cgfx.rectFmtGREY8;
  2169.       ELSE
  2170.         colorType:=cgfx.rectFmtRGB;
  2171.         dispModulo:=dispModulo*3;
  2172.         frameSize:=frameSize*3;
  2173.       END;
  2174.     END;
  2175.     IF (minDepth<=8) & (maxDepth>8) THEN frameSize:=frameSize*3; END;
  2176.     ol.New(videoData,size);
  2177.     ol.New(videoDataDec,mu.max(size,frameSize));
  2178. (*
  2179.     ol.New(videoDataDec,mu.max(size,frameSize)*6);
  2180.     videoDataDec:=y.VAL(e.LSTRPTR,y.VAL(LONGINT,videoDataDec)+frameSize);
  2181. *)
  2182.     IF ~o.noVideo THEN
  2183.       IF colorReduction THEN
  2184.         displayProc:=DisplayFrameAGA;
  2185.         IF animDepth=4 THEN
  2186.           fastc2pProc:=FastC2P4;
  2187.         ELSE
  2188.           fastc2pProc:=FastC2P8;
  2189.         END;
  2190.       ELSE
  2191.         displayProc:=DisplayFrameCyberGfx;
  2192.       END;
  2193.     ELSE
  2194.       displayProc:=DisplayFrameDummy;
  2195.       colorReduction:=FALSE;
  2196.     END;
  2197.     currentCodec:=0;
  2198.     decoderProc:=codecs[0].decoder;
  2199.     decoderSpec:=codecs[0].special;
  2200.     calcWidth:=codecs[0].width;
  2201.     calcHeight:=codecs[0].height;
  2202.   END;
  2203.   RETURN ret;
  2204. END AllocBuffers;
  2205. (* \\\ ------------------------------------------------------------------------- *)
  2206.  
  2207. BEGIN
  2208.   NEW(cmap);
  2209. CLOSE
  2210.   io.Close(videoFile);
  2211.   CloseDisplay();
  2212. END CyberQTVideo.
  2213.  
  2214.